# Realtor.com Agents Scraper (`automation-lab/realtor-agents-scraper`) Actor

Scrape Realtor.com agents across one or more US markets. Extract names, phones, emails, brokerages, office addresses, listing activity, and matched search locations.

- **URL**: https://apify.com/automation-lab/realtor-agents-scraper.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** Lead generation, Real estate
- **Stats:** 109 total users, 25 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.00 / 1,000 agent scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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

## Realtor.com Agents Scraper

Scrape real estate agent contact data from [Realtor.com](https://www.realtor.com) without an API key or login. Extract agent names, direct phone numbers, email addresses, brokerages, and office addresses across one or more US cities, states, or ZIP codes. Identifies agents actively working listings in your target markets.

### What does Realtor.com Agents Scraper do?

🏡 Realtor.com Agents Scraper extracts agent contact data from one of the most active real estate marketplaces in the US. By scanning the listing activity for a location, it identifies all agents who currently have or recently had active listings — the most productive agents in any market.

Enter one location with the backward-compatible `location` field, or add several markets with `locations`. Choose to search across active for-sale listings, recently sold transactions, or both. The scraper handles pagination automatically and deduplicates by agent ID across the entire run so every result is unique.

Each output record includes the agent's name, primary phone, email, brokerage, office address, a constructed Realtor.com profile link, and a listing-count field showing how many deals they appeared in — a direct signal of market activity.

### Who is it for?

**📋 CRM vendors and marketing automation platforms**

- Prospect real estate agents as potential customers for Follow Up Boss, kvCORE, LionDesk, and similar platforms
- Build targeted agent lists segmented by market, brokerage, or activity level
- Enrich existing agent contact databases with fresh phones and emails

**🏦 Mortgage lenders and title companies**

- Identify top-producing agents in your target market for referral partnership outreach
- Agents with high listing counts are the highest-priority referral targets
- Build purchase loan pipeline by reaching listing agents with active inventory

**🔄 Brokerage recruiters**

- Source agent candidates across competing brokerages in your market
- Identify active agents by listing count for recruiting campaigns
- Target sellers agents or buyer agents specifically via the `listingStatus` filter

**💼 Real estate technology companies**

- Prospect agents for showing platforms, e-signature tools, transaction management software
- Build outbound sales lists segmented by market size and agent activity
- Research market coverage and agent density before launching in a new city

**📸 Real estate service vendors**

- Find agents who have active listings and need photography, virtual staging, or video services
- Target listing agents in specific price tiers or ZIP codes
- Build local outreach lists for marketing services

**📊 Researchers and data teams**

- Analyze agent market concentration and brokerage dominance by city
- Track active agent counts and brokerage splits across markets
- Build datasets for real estate industry research and competitive intelligence

### Why use Realtor.com Agents Scraper?

Collecting agent contact information manually takes hours per market. This actor automates the entire process:

- **No login or API key required** — works from public Realtor.com listing data
- **Multi-market collection** — search several cities or ZIP codes in one run with one total result cap
- **Structured output** — clean JSON with 15+ fields per agent, ready for import into any CRM or database
- **Active agents only** — by scanning listing activity, you get agents who are currently doing deals, not stale directory entries
- **Listing-count signal** — know how many deals each agent has been involved in at a glance
- **Reliable at scale** — uses US residential proxy rotation, the same infrastructure powering our `realtor-scraper` (active listings scraper) at 99%+ success rate

### What data can you extract?

Each agent record includes:

| Field | Description |
|-------|-------------|
| `agentId` | NRDS ID or MLS identifier for the agent |
| `name` | Full name |
| `profileUrl` | Constructed Realtor.com profile link |
| `websiteUrl` | Agent's personal or brokerage website (when available) |
| `photoUrl` | Profile photo URL (when available) |
| `brokerage` | Name of the brokerage |
| `brokerageEmail` | Brokerage email address (when available) |
| `phones` | All phone numbers with type labels (Mobile, Office, etc.) |
| `primaryPhone` | Best direct phone number (prefers mobile) |
| `email` | Direct email address |
| `city` | Agent's city |
| `state` | State code (e.g. `TX`) |
| `postalCode` | ZIP code |
| `officeAddress` | Full office address |
| `listingCount` | Number of listings the agent appeared in — activity signal |
| `agentRole` | Role in found listings: `seller` (listing agent) or `buyer` (buyer's agent) |
| `location` | First requested location where this agent was found (kept for backward compatibility) |
| `matchedLocations` | All requested markets where the agent was found; included on multi-location runs |
| `scrapedAt` | ISO 8601 timestamp of extraction |

### How much does it cost to scrape Realtor.com agents?

Pricing uses Apify's **pay-per-event** model — you only pay for what you extract.

**Run start fee:** $0.005 (one-time per run, all plans)

**Per-agent price by Apify plan:**

| Plan | Price per agent |
|------|----------------|
| FREE | $0.00575 |
| BRONZE | $0.005 |
| SILVER | $0.0039 |
| GOLD | $0.003 |
| PLATINUM | $0.002 |
| DIAMOND | $0.0014 |

Higher-tier plans deliver significant per-agent savings for large-scale scraping.

**Example costs (BRONZE plan):**

- 100 agents ≈ $0.51 (start + 100 × $0.005)
- 500 agents ≈ $2.51
- 1,000 agents ≈ $5.01

**Example costs (DIAMOND plan):**

- 100 agents ≈ $0.145
- 500 agents ≈ $0.705
- 1,000 agents ≈ $1.405

Compared to purchasing agent contact lists at $0.50–$5 per record from data brokers, this delivers equivalent contact data at a fraction of the cost.

> **Tip:** Set `maxResults` to match exactly what you need. Unused capacity is not charged.

### How to scrape Realtor.com agents

1. Go to the actor's page on Apify Store and click **Try for free**.
2. Enter one **Location**, or add a list under **Multiple locations** (for example `Austin, TX` and `Round Rock, TX`).
3. Choose a **Listing type** — `both` (default) searches the widest set of active agents.
4. Set **Max results** (default 100).
5. Click **Save & Run**.
6. Download results as JSON, CSV, or Excel from the **Dataset** tab.

For recurring data collection, use **Scheduled runs** to automate daily or weekly agent list updates.

### Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `location` | string | *(optional)* | One city + state (`New York, NY`), city (`Austin`), or ZIP (`10001`); existing Tasks remain compatible |
| `locations` | string\[] | *(optional)* | Several cities, states, or ZIP codes to search in one run |
| `listingStatus` | string | `both` | Which listing types to scan: `both`, `for_sale`, `sold`, `for_rent` |
| `maxResults` | integer | `100` | Total max unique agents across all locations (1–5,000) |
| `maxRequestRetries` | integer | `3` | HTTP retry attempts per request |

Provide at least one non-empty value through `location` or `locations`. Values are trimmed and deduplicated case-insensitively. For multi-location runs, the total `maxResults` allowance is distributed as evenly as possible across the normalized locations so one large market does not consume the entire run. Agents found in several markets are emitted once with every match in `matchedLocations`.

**Location format examples:**

- `New York, NY` — New York City agents
- `Los Angeles, CA` — LA agents
- `90210` — Beverly Hills by ZIP
- `Austin` — Austin agents (no state required for major cities)

**Listing type guide:**

- `both` — searches for-sale AND recently sold listings, maximizing unique agent coverage
- `for_sale` — only agents with active for-sale listings (currently inventory-holding agents)
- `sold` — only agents who recently closed a sale
- `for_rent` — rental market agents

### Output examples

```json
{
  "agentId": "785038427",
  "name": "Clark Gray",
  "profileUrl": "https://www.realtor.com/realestateagents/Clark-Gray_785038427",
  "websiteUrl": null,
  "photoUrl": "https://ap.rdcpix.com/abc123photo.jpg",
  "brokerage": "Mercer Street Group, LLC",
  "brokerageEmail": "amy@mercerstreetgroup.com",
  "phones": [
    { "number": "5125549618", "type": "Mobile" }
  ],
  "primaryPhone": "5125549618",
  "email": "clark@clarkgray.com",
  "city": "Austin",
  "state": "TX",
  "postalCode": "78749",
  "officeAddress": "4301 W. William Cannon Drive, #K-200, Austin, TX, 78749",
  "listingCount": 3,
  "agentRole": "seller",
  "location": "Austin, TX",
  "scrapedAt": "2025-08-15T14:22:10.000Z"
}
```

### Tips for best results

**Use `listingStatus: "both"` for maximum coverage**
Searching both for-sale and sold listings surfaces the most unique agents for a market. A listing-only search shows who has active inventory; a sold-only search captures agents who recently closed deals. `both` gives you the union.

**listingCount signals productivity**
Agents with `listingCount >= 3` appeared in three or more listings during your search — a strong signal of market activity. Filter by this field after export to prioritize your outreach.

**Match location to market size**

- Large metros (New York, LA, Houston): set `maxResults` to 200–1000 to capture top agents
- Mid-size cities (Austin, Denver, Miami): 100–300 agents covers most of the market
- ZIP code searches: 20–100 agents is typically all that's available for a single ZIP

**Schedule for freshness**
Agent data changes over time — phone numbers, brokerages, and email addresses update. Schedule a weekly run on your target markets to keep your CRM data current.

**Combine with realtor-scraper for full market intelligence**
Pair this actor with our `realtor-scraper` (property listings) to build a complete picture: who's selling what at what price in any market.

### Supported locations

Any US market with listings on Realtor.com. This includes all 50 states and US territories. Best coverage in major metro areas; rural areas may return fewer agents.

**Top markets with extensive agent data:**
New York, NY · Los Angeles, CA · Chicago, IL · Houston, TX · Phoenix, AZ · Dallas, TX · Miami, FL · Atlanta, GA · Seattle, WA · Denver, CO

### Integrations

Export results directly to your preferred tools:

- **Google Sheets** — Use the Apify integration to push dataset items into a spreadsheet on each run
- **Zapier / Make** — Trigger downstream CRM workflows whenever new agents are scraped
- **HubSpot / Salesforce** — Pipe agent contact data into your CRM via Apify's native integrations
- **Webhooks** — POST results to your own endpoint in real time via Actor run webhooks
- **CSV / Excel** — Download from the Dataset tab in any format for manual import

### API usage

Run this actor programmatically and retrieve results using the Apify API.

**Node.js (ApifyClient)**

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('automation-lab/realtor-agents-scraper').call({
    locations: ['Austin, TX', 'Round Rock, TX'],
    maxResults: 50,
    listingStatus: 'both',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**Python (ApifyClient)**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("automation-lab/realtor-agents-scraper").call(run_input={
    "location": "Austin, TX",
    "maxResults": 50,
    "listingStatus": "both",
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

**cURL**

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~realtor-agents-scraper/runs" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -d '{"location":"Austin, TX","maxResults":50}'
```

Then fetch results:

```bash
curl "https://api.apify.com/v2/acts/automation-lab~realtor-agents-scraper/runs/last/dataset/items" \
  -H "Authorization: Bearer YOUR_API_TOKEN"
```

Full API documentation: [Apify API Reference](https://docs.apify.com/api/v2)

### Use with AI agents via MCP

Connect your AI client to the actor-scoped Apify MCP endpoint:

`https://mcp.apify.com/?tools=automation-lab/realtor-agents-scraper`

#### Claude Code

```bash
claude mcp add --transport http realtor-agents-scraper "https://mcp.apify.com/?tools=automation-lab/realtor-agents-scraper"
```

#### Claude Desktop, Cursor, and VS Code

Add this server to the MCP JSON configuration in **Claude Desktop**, **Cursor**, or **VS Code**:

```json
{
  "mcpServers": {
    "realtor-agents-scraper": {
      "url": "https://mcp.apify.com/?tools=automation-lab/realtor-agents-scraper"
    }
  }
}
```

Example prompts you can try with MCP:

- "Use Realtor.com Agents Scraper to find up to 50 active agents across Austin and Round Rock, Texas."
- "Collect sold-listing agents in ZIP codes 90210 and 90024, then summarize the brokerages represented."
- "Find agents in Denver and Boulder and return only records with a published phone or email."

The actor returns structured JSON suitable for property-search agents, CRM enrichment, RAG pipelines, and market-monitoring workflows. For multi-source coverage, combine it with [Zillow Scraper](https://apify.com/automation-lab/zillow-scraper), [Redfin Scraper](https://apify.com/automation-lab/redfin-scraper), or [Realtor.com Scraper](https://apify.com/automation-lab/realtor-scraper).

### Legality of scraping Realtor.com

Web scraping publicly available data is generally legal under US law when:

- The data is publicly accessible (no login required) — ✅ agent contact data on listings is public
- You are not circumventing authentication systems — ✅ this actor accesses public listing data only
- You comply with the site's Terms of Service for your use case

Realtor.com's Terms of Service restrict automated access for commercial data redistribution. Users of this actor are responsible for ensuring their use case complies with Realtor.com's ToS and applicable laws, including the CCPA for California residents' data and the CAN-SPAM Act for commercial email use.

**This actor is intended for legitimate B2B lead generation, research, and data enrichment purposes.** Always review the Terms of Service of the target website and the laws applicable to your jurisdiction before scraping.

### FAQ

**Why do some agents have `null` for email or phone?**
Not all agents publish their contact information on every listing. The actor extracts whatever is available in the listing data. Agents with more listings generally have more complete contact data.

**Why does the actor return fewer results than my maxResults setting?**
Some markets have fewer active agents than the requested `maxResults`. Small ZIP codes and rural areas typically have 20–100 unique agents. The actor returns all available unique agents.

**Can I scrape multiple locations at once?**
Yes. Set `locations` to a list such as `["Austin, TX", "Round Rock, TX"]`. `maxResults` remains one total cap, agents are deduplicated across markets, and multi-location records include `matchedLocations`. Existing Tasks using a single `location` require no changes.

**What is the listingCount field?**
`listingCount` counts how many times an agent appeared across the listings searched during your run. A higher count means the agent is more active in that market. This is the most reliable activity signal available from public listing data.

**How fresh is the data?**
The actor fetches live listing data from Realtor.com on each run. Data is as current as Realtor.com's active listing database.

**The actor returned the same agent multiple times — is that a bug?**
No — the actor deduplicates by agent NRDS ID. Each result is a unique agent. If you see what looks like duplicates, check the `agentId` field — they are different agents with similar names.

### Build a production real-estate data workflow

Use this actor as one source in a repeatable property-data pipeline: scrape listings from the source site, export structured JSON/CSV/Excel, schedule refreshes, and send results to your dashboard, CRM, warehouse, or AI/LLM workflow.

Pair Realtor.com agent profiles with Realtor.com property listings when your workflow needs both broker/agent lead enrichment and market supply data. Use agent data for CRM enrichment or outreach research, then combine it with listing exports for market coverage.

For broader coverage, combine it with related Automation Lab actors:

- US residential listings: [Zillow Scraper](https://apify.com/automation-lab/zillow-scraper), [Redfin Scraper](https://apify.com/automation-lab/redfin-scraper), [Realtor.com Scraper](https://apify.com/automation-lab/realtor-scraper)
- US agent lead data: [Realtor.com Agents Scraper](https://apify.com/automation-lab/realtor-agents-scraper)
- UK and Europe: [Rightmove Scraper](https://apify.com/automation-lab/rightmove-scraper), [ImmoScout24 Germany Real Estate Scraper](https://apify.com/automation-lab/immoscout24-de-scraper), [Imovirtual Scraper](https://apify.com/automation-lab/imovirtual-scraper), [RE/MAX Portugal Scraper](https://apify.com/automation-lab/remax-portugal-scraper), [Sreality.cz Real Estate Scraper](https://apify.com/automation-lab/sreality-cz-real-estate-scraper), [Pisos.com Real Estate Scraper](https://apify.com/automation-lab/pisos-com-real-estate-scraper)
- Middle East / South Asia: [PropertyFinder Scraper](https://apify.com/automation-lab/propertyfinder-scraper), [Zameen Property Scraper](https://apify.com/automation-lab/zameen-property-scraper)
- Short-term rentals: [Airbnb Scraper](https://apify.com/automation-lab/airbnb-listing) and [Airbnb Reviews Scraper](https://apify.com/automation-lab/airbnb-reviews)

### Related real-estate actors

- [Zillow Scraper](https://apify.com/automation-lab/zillow-scraper) — Zillow search/detail data, property attributes, photos, and Zestimates
- [Redfin Scraper](https://apify.com/automation-lab/redfin-scraper) — fast Redfin listing data for cities, ZIP codes, neighborhoods, and counties
- [Realtor.com Scraper](https://apify.com/automation-lab/realtor-scraper) — Realtor.com for-sale, rental, and recently sold listings
- [Realtor.com Agents Scraper](https://apify.com/automation-lab/realtor-agents-scraper) — active real-estate agent contacts and brokerage enrichment

# Actor input Schema

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

One city, state, or ZIP code. Existing Tasks can keep using this field; to search several markets in one run, use <code>locations</code> instead.

## `locations` (type: `array`):

Optional list of cities, states, or ZIP codes to search in one run. Duplicate and blank values are ignored. <code>maxResults</code> is the total cap across all locations.

## `listingStatus` (type: `string`):

Search agents from active for-sale listings, recently sold listings, or both. <code>both</code> finds the most agents.

## `maxResults` (type: `integer`):

Maximum number of unique agent profiles to extract across all requested locations. Each result is charged separately.

## `maxRequestRetries` (type: `integer`):

Number of retry attempts for failed HTTP requests.

## Actor input object example

```json
{
  "location": "New York, NY",
  "listingStatus": "both",
  "maxResults": 20,
  "maxRequestRetries": 3
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset containing all scraped Realtor.com agents.

# 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 = {
    "location": "New York, NY",
    "listingStatus": "both",
    "maxResults": 20,
    "maxRequestRetries": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/realtor-agents-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 = {
    "location": "New York, NY",
    "listingStatus": "both",
    "maxResults": 20,
    "maxRequestRetries": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/realtor-agents-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 '{
  "location": "New York, NY",
  "listingStatus": "both",
  "maxResults": 20,
  "maxRequestRetries": 3
}' |
apify call automation-lab/realtor-agents-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/realtor-agents-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/LA8KtNyYbk2qo67eg/builds/UTpYiTzYtFZMyDDiL/openapi.json