# Redfin Agent Contact Extractor — Phones & Brokerages (`axlymxp/redfin-agent-contact-extractor`) Actor

Build a live Redfin listing-agent database for any US market. Returns one deduped row per agent with direct phone, brokerage, listing count, total list volume and areas covered. Filter by price band, property type or sold deals. Pay only for the leads you get.

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

## Pricing

from $8.00 / 1,000 dataset items

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Redfin Agent Contact Extractor — Names, Direct Phones & Brokerages

Build a **live** Redfin listing-agent database for any US market. Point it at a city, ZIP or county and get back one clean row per agent — with their **direct phone**, brokerage, how many listings they currently hold, and how much volume those listings represent.

Not a stale, pre-collected list. Every row comes from listings that are on the market (or just sold) *right now*, in exactly the market and price band you asked for.

### Who it's for

- **B2B sales teams selling to agents** — CRM, photography, staging, signage, mortgage, title, iBuyer and marketing vendors.
- **Brokerage recruiters** — find producing agents by listing count and list volume in a target market.
- **Lead-gen agencies** — build territory-scoped calling and outreach lists on demand.
- **Market analysts** — measure brokerage share of listings and dollar volume in any ZIP.

### Why this data is hard to get

The listing agent's **direct phone** lives on the property detail page, which redfin.com serves only behind an anti-bot token. This actor reads Redfin's mobile API instead, where that data is available directly — which is why it can scan hundreds of listings and roll them up without browsers, CAPTCHA solving or proxies.

In spot checks across Austin, TX, **every scanned listing** returned an agent name and a direct phone number.

### Output fields

| Field | Type | Description |
| --- | --- | --- |
| `agent_name` | string | Listing agent's full name |
| `agent_phone` | string | **Agent's direct phone number** |
| `brokerage` | string | Brokerage / firm name |
| `brokerage_phone` | string | Brokerage office phone |
| `is_redfin_agent` | boolean | In-house Redfin agent |
| `is_partner_agent` | boolean | Redfin partner agent |
| `listing_count` | integer | Listings this agent held in the scan |
| `total_list_volume` | integer | Combined list price of those listings (USD) |
| `avg_list_price` | integer | Average list price |
| `min_list_price`, `max_list_price` | integer | Price range they work in |
| `cities` | array | Cities they list in |
| `states` | array | States they list in |
| `zip_codes` | array | ZIP codes they list in |
| `property_types` | array | Property types they list |
| `sample_listing_url` | string | One of their live listings |
| `sample_listing_address` | string | That listing's address |
| `listings` | array | Every listing (with `includeListings`) — address, price, beds, baths, URL |
| `search_location`, `scraped_at` | string | Provenance |

Rows are **deduplicated per agent** — an agent with five listings appears once, with `listing_count: 5` and the combined volume.

### Use cases

- **Territory calling lists** — scan a metro, set `requirePhone: true`, and export straight to CSV for your dialer.
- **Find top producers** — set `minListingsPerAgent: 3` to filter down to agents with real inventory, then sort by `total_list_volume`.
- **Luxury-segment targeting** — set `minPrice: 1500000` to reach only agents working high-value listings.
- **Recruit closers, not just listers** — set `listingType: "sold"` to find agents who actually *closed* deals in the last 90 days.
- **Brokerage market share** — group rows by `brokerage` and sum `total_list_volume` for a share-of-market view of any ZIP.
- **Independent-agent targeting** — set `excludeRedfinAgents: true` to skip Redfin's in-house team.

### Input parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `locations` | array | — | Cities, ZIPs, neighborhoods or counties |
| `listingType` | enum | `for_sale` | `for_sale` (active inventory) or `sold` (recent closers) |
| `maxListingsToScan` | integer | `300` | Listings to read agents from, split across locations |
| `maxItems` | integer | `100` | Max agent rows returned — your cost cap |
| `requirePhone` | boolean | `true` | Only return agents with a direct phone |
| `minListingsPerAgent` | integer | `1` | Filter to higher-volume agents |
| `excludeRedfinAgents` | boolean | `false` | Keep only third-party brokerage agents |
| `propertyTypes` | array | all | Which listings to scan |
| `minPrice`, `maxPrice` | integer | — | Target a price band |
| `soldWithinDays` | integer | `90` | For `listingType: "sold"` |
| `includeListings` | boolean | `false` | Attach each agent's individual listings |
| `proxyConfiguration` | object | disabled | Optional proxy |

> **Scanning vs. results.** Agents are discovered *from listings*, so `maxListingsToScan` controls how much inventory is read and `maxItems` controls how many agent rows you are charged for. Scanning more listings finds more unique agents and produces more accurate `listing_count` and volume figures.

### Example input

```json
{
    "locations": ["Austin, TX"],
    "listingType": "for_sale",
    "maxListingsToScan": 300,
    "maxItems": 150,
    "requirePhone": true,
    "minListingsPerAgent": 2,
    "minPrice": 500000
}
```

### Example output

```json
{
    "agent_name": "Patricia Smith",
    "agent_phone": "512-431-5074",
    "brokerage": "Keller Williams Realty",
    "brokerage_phone": "512-448-4111",
    "is_redfin_agent": false,
    "is_partner_agent": false,
    "listing_count": 3,
    "total_list_volume": 1119900,
    "avg_list_price": 373300,
    "min_list_price": 210000,
    "max_list_price": 525000,
    "cities": ["Austin"],
    "states": ["TX"],
    "zip_codes": ["78704", "78745", "78759"],
    "property_types": ["SINGLE_FAMILY", "CONDO_COOP"],
    "sample_listing_url": "https://www.redfin.com/TX/Austin/...",
    "sample_listing_address": "8000 Forest Mesa Dr Unit B",
    "search_location": "Austin",
    "scraped_at": "2026-09-21T09:14:03Z"
}
```

### Scheduling & webhooks

Use Apify **Schedules** to refresh your agent list weekly as new inventory comes to market, and **Webhooks** to push each finished run into your CRM, Zapier or Make. Export as JSON, CSV, Excel or XML from the dataset API.

### Use with AI assistants (MCP)

Works with the [Apify MCP server](https://apify.com/apify/actors-mcp-server), so Claude, ChatGPT and other MCP-capable assistants can call it directly — for example "find me the top 20 listing agents in Scottsdale working homes over $1M, with phone numbers".

### FAQ

**Are these agents' real phone numbers?**
They are the contact numbers published with each MLS listing on Redfin — typically the agent's direct line. Rows without a usable number are filtered out by default (`requirePhone: true`).

**Do I get email addresses?**
No. Redfin does not publish listing-agent email addresses on property listings, so this actor does not claim to provide them. It returns the agent's direct phone and the brokerage phone.

**How many agents will I get?**
It depends on the market and on `maxListingsToScan`. Because busy agents hold several listings, expect roughly 0.6–0.9 unique agents per listing scanned — around 200–270 agents from a 300-listing scan.

**Why did I get fewer agent rows than listings scanned?**
That is deduplication working. An agent with five listings is one row with `listing_count: 5`, not five rows.

**How fresh is the data?**
Fetched live from Redfin on every run. There is no cached database behind this actor, which is why the listing counts and volumes reflect current inventory.

**Do I need a proxy?**
No. The actor uses Redfin's mobile API, which needs no proxies, cookies or CAPTCHA solving.

**Is this legal?**
The actor collects publicly available listing information, including the agent contact details Redfin publishes with each listing. You are responsible for how you use it — including compliance with Redfin's terms, MLS rules, and marketing and privacy laws such as the TCPA and applicable do-not-call rules before contacting anyone.

# Actor input Schema

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

US cities, ZIP codes, neighborhoods or counties whose listing agents you want. Examples: "Austin, TX", "78704", "Brooklyn, NY".

## `listingType` (type: `string`):

Agents are discovered from listings. 'for\_sale' finds agents with active inventory right now; 'sold' finds agents who have recently closed deals in the market.

## `maxListingsToScan` (type: `integer`):

How many listings to read agent details from, split across your locations. More listings means more unique agents and better listing-count stats. Roughly 0.5s per listing.

## `maxItems` (type: `integer`):

Maximum number of agent rows pushed to the dataset. You are charged per agent, so this is also your cost cap.

## `requirePhone` (type: `boolean`):

Skip agents whose listings did not disclose a phone number, so every row you pay for is contactable.

## `minListingsPerAgent` (type: `integer`):

Only return agents seen on at least this many listings in the scan. Raise it to target high-volume producers.

## `excludeRedfinAgents` (type: `boolean`):

Filter out in-house Redfin agents and keep only third-party brokerage agents.

## `propertyTypes` (type: `array`):

Only scan listings of these property types. Leave empty for all.

## `minPrice` (type: `integer`):

Target agents working a given price band, e.g. set 1000000 for luxury agents.

## `maxPrice` (type: `integer`):

Maximum list price. For rentals this is the monthly rent.

## `soldWithinDays` (type: `integer`):

Only used when scanning sold listings. Defaults to 90.

## `includeListings` (type: `boolean`):

Adds a 'listings' array to every agent row with the individual properties they are listing (address, price, beds, baths, URL).

## `proxyConfiguration` (type: `object`):

Optional. The Redfin mobile API does not require a proxy, but you can route traffic through one for higher parallelism or geo control.

## Actor input object example

```json
{
  "locations": [
    "Austin, TX",
    "Dallas, TX"
  ],
  "listingType": "for_sale",
  "maxListingsToScan": 300,
  "maxItems": 100,
  "requirePhone": true,
  "minListingsPerAgent": 1,
  "excludeRedfinAgents": false,
  "propertyTypes": [],
  "soldWithinDays": 90,
  "includeListings": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "locations": [
        "Austin, TX"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("axlymxp/redfin-agent-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 = { "locations": ["Austin, TX"] }

# Run the Actor and wait for it to finish
run = client.actor("axlymxp/redfin-agent-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 '{
  "locations": [
    "Austin, TX"
  ]
}' |
apify call axlymxp/redfin-agent-contact-extractor --silent --output-dataset

```

## MCP server setup

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