# Redfin Scraper — Listings + Agent Database (Email & Phone) (`memo23/apify-redfin-cheerio-ppe`) Actor

Redfin scraper with an instant agent database — 10,800+ agents, all 50 states, email + phone + deal stats, uncapped. Filter by State/City/Brokerage, no scraping needed. Or live-scrape search URLs, property details, agents & emails across sale, sold & rental. Pure HTTP. JSON/CSV.

- **URL**: https://apify.com/memo23/apify-redfin-cheerio-ppe.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** Real estate, AI, Agents
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 agent records

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Scraper — Listings + Agent Database (Email & Phone)

Pull Redfin agent contacts **instantly** from a pre-collected database of **10,800+ agents across all 50 US states + DC** — email, phone, brokerage, ratings, deal stats — or live-scrape any Redfin search, property, or agent-directory URL for **sale, sold, and rental** listings with the fields other Redfin scrapers skip: price history, tax & climate risk, the Redfin Estimate, schools, and neighborhood stats.

> This is the only Redfin scraper on Apify that returns agent contact info (email + phone). Every other Redfin actor on the Store scrapes properties only.

### ⚡ Instant Redfin Agent Database — 10,800+ agents, all 50 states

The fastest way to get Redfin agent contacts: skip scraping entirely and pull straight from our continuously-growing database of **10,842 Redfin agents covering all 50 US states + DC, zero gaps** — instant, no proxies, nothing to get blocked.

**How to use it:** in the **⚡ Instant Database Mode** section of the input, set a **State** (2-letter code, e.g. `CA`) — optionally narrow by **City** or **Brokerage**, or filter to only agents with an **email** or **phone** on file — and run. Leave the live-scraping start URLs empty. You're billed only per agent delivered.

**Each database agent includes:** name, email, phone, brokerage, job title, license info, star rating & review count, past-year and lifetime deal counts, lifetime transaction volume, active listings, premier/veteran/active status, languages, primary service regions, property types, neighborhoods, bio, and photo.

**Coverage:** 10,842 agents total — **99.99% with an email on file**, 18% with a phone number. The roster is a mix of Redfin's own in-house agents and the partner/external brokerage agents (Compass, NextHome, and others) that Redfin's agent-directory pages surface. Top states: California (1,897), Florida (872), Texas (728), Illinois (622), Washington (583), Pennsylvania (460), New York (430).

**Need a whole state as a clean CSV, or pushed to your CRM via API?** Reach out via the Support section below for bulk or full-state datasets.

### Why Use This Scraper?

- ✅ **The only Redfin scraper with agent contacts** — 10,800+ agents with email, instantly, no live scraping needed
- ✅ **All 50 states + DC covered**, verified with zero gaps
- ✅ **Sale, sold AND rental** listings in one actor, plus a `soldTimeframe` window for comps
- ✅ **The property data competitors skip** — price history, tax & climate risk, schools, walk/transit scores, the Redfin Estimate (AVM)
- ✅ **Beats the ~350-result search cap** — tiles the map to pull the full result set
- ✅ **Optional market summary** — median price, $/sqft, days-on-market and breakdowns by type/city/zip, computed at no extra request cost
- ✅ **Pure HTTP** — no headless browser, no CAPTCHA solver

### Overview

This actor serves two audiences from one tool: **lead-gen teams and brokerages** who want Redfin agent contacts without scraping, and **investors, analysts, and proptech teams** who want deep property data for sale, sold, and rental listings.

Agent runs (Instant Database, or a live agent-directory / profile scrape) emit a flat agent row per agent. Property runs (search URL, property URL, or keyword) emit a deep, faithful capture of the Redfin listing — the same rich sections Redfin shows on the page, so the output is large and nested by design. Set `flattenOutput: true` for a flattened view.

### Supported Inputs

#### Instant Database filters (no URL needed)

| Field | Example | Notes |
|---|---|---|
| `dbState` | `CA` | 2-letter state code |
| `dbCity` | `Los Angeles` | optional, matches the agent's service regions |
| `dbBrokerage` | `Compass` | optional, substring match on brokerage name |
| `dbHasEmail` | `true` | only return agents with an email on file |
| `dbHasPhone` | `true` | only return agents with a phone on file |
| `instantDatabase` | `true` | force Instant Database mode (auto-triggers if any filter above is set) |

#### Live-scrape URL types

| URL type | Pattern | Example |
|---|---|---|
| Search | any Redfin search page, with on-page filters | `https://www.redfin.com/city/30772/TX/Austin/filter/property-type=house,min-price=200k` |
| Property detail | a single listing page | `https://www.redfin.com/TX/Austin/1204-2nd-Ave-NW-55912/home/64446623` |
| Agent directory | a city's agent-directory page | `https://www.redfin.com/city/30772/TX/Austin/real-estate-agents` |
| Agent profile | an individual agent's public profile | `https://www.redfin.com/real-estate-agents/jane-doe` |
| Short link | a `redf.in/...` short URL | resolved automatically to its full target |

#### Copy-pasteable startUrls

```json
{
  "startUrls": [
    "https://www.redfin.com/city/30772/TX/Austin/filter/property-type=house,min-price=200k",
    "https://www.redfin.com/city/30772/TX/Austin/real-estate-agents"
  ]
}
````

#### Keyword / search mode

```json
{
  "searchKeyword": "Austin, TX",
  "searchMode": "sale"
}
```

#### Unsupported inputs

- ❌ Content behind a Redfin login (saved searches, saved agents, messaging)
- ❌ Countries outside Redfin's US coverage
- ❌ Non-redfin.com domains

### Use Cases

| Audience | Use case |
|---|---|
| **Lead-gen teams / brokerages** | Pull thousands of Redfin agent contacts instantly by state or city — no scraping |
| **Recruiters / roster building** | Build brokerage rosters filtered by state, brokerage name, or review count |
| **Investors / iBuyers** | Price history + Redfin Estimate + days-on-market to spot mispriced or stale listings |
| **Lenders / insurers** | Tax, cost-of-ownership and climate/flood risk per property |
| **Market analysts** | The market-summary record — median price, $/sqft and inventory by city/zip |
| **Relocation / proptech** | Schools, walk/transit scores and neighborhood stats for any address |

### How It Works

![How Redfin Scraper works](https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/how-it-works-redfin.png)

1. **Choose a mode** — Instant Database (state/city/brokerage filters) for agent contacts, or live scrape (search URL, property URL, agent-directory URL, or a keyword) for listings
2. **Instant Database path** — the actor queries our pre-collected store and returns matching agents in seconds; no requests to Redfin at all
3. **Live-scrape path** — the actor calls Redfin's own data APIs (no browser), tiles the map to beat the ~350-result cap, and captures every detail section: price history, tax, schools, climate risk, walk score, Redfin Estimate, market stats, photos, floor plans, amenities
4. **Optional enrichment** — a market-summary rollup, or best-effort email enrichment on live agent scrapes
5. **Output** — one row per agent or property, JSON or CSV

### Input Configuration

#### Input fields

| Field | Type | Default | Notes |
|---|---|---|---|
| `dbState` | string | — | Instant Database: 2-letter state code |
| `dbCity` | string | — | Instant Database: city / region, optional |
| `dbBrokerage` | string | — | Instant Database: brokerage name contains, optional |
| `dbHasEmail` | boolean | `false` | Instant Database: only agents with an email |
| `dbHasPhone` | boolean | `false` | Instant Database: only agents with a phone |
| `instantDatabase` | boolean | `false` | Force Instant Database mode |
| `startUrls` | array | — | Redfin search / property / agent-directory URLs (live scrape) |
| `searchKeyword` | string | — | Build a search from a place name instead of a URL |
| `searchMode` | string | `sale` | `sale`, `sold`, or `rental` |
| `soldTimeframe` | string | `1mo` | Window for sold comps |
| `maxItems` | integer | 600 | Cap on rows (also caps Instant Database delivery) |
| `includeProfileDetails` | boolean | `false` | Deep agent-profile detail on live agent-directory runs |
| `includeMarketSummary` | boolean | `false` | Append one market-summary record (live scrape only) |
| `enrichEmails` | boolean | `false` | Best-effort contact-email lookup per result on live scrape (billed separately, see Pricing) |
| `flattenOutput` | boolean | `false` | Flatten the nested property structure |
| `includesAboveTheFoldData`, `includesBelowTheFoldData`, `includesParcelBounds`, `includesBannerData`, `includesAmenitiesData`, `includesWalkScoreData`, `includesSellsideThresholdData`, `includesFloorPlansData`, `includesProtoHomeData` | boolean | `true` | Toggle individual property detail sections on/off to trim output |
| `storeName` | string | — | Name a persistent store to dedupe & retain data across runs |
| `maxConcurrency` / `minConcurrency` / `maxRequestRetries` | integer | 10 / 1 / 3 | Throughput & resilience (live scrape only) |
| `proxy` | object | Residential | Proxy configuration (live scrape only — Instant Database needs none) |

#### Common scenarios

**1. Instant Database — every agent in a state with an email**

```json
{
  "dbState": "CA",
  "dbHasEmail": true,
  "maxItems": 500
}
```

**2. Instant Database — narrow by city and brokerage**

```json
{
  "dbState": "TX",
  "dbCity": "Austin",
  "dbBrokerage": "Compass",
  "maxItems": 100
}
```

**3. Live scrape — sale listings by keyword with a market summary**

```json
{
  "searchKeyword": "Austin, TX",
  "searchMode": "sale",
  "maxItems": 200,
  "includeMarketSummary": true
}
```

### Pricing

This actor uses Apify's pay-per-event pricing — you're billed only for what's actually delivered:

| Event | Price | Charged when |
|---|---|---|
| **Agent record** | $0.002 | Per agent delivered — Instant Database or live scrape |
| **Property record** | $0.002 | Per property delivered — includes every detail section (Redfin Estimate, Walk Score, amenities, floor plans) at no extra charge |
| **Email enrichment** | $0.02 | Per email found via `enrichEmails` on a live agent scrape — never charged on a miss |
| Actor start | Apify platform rate | Standard per-GB run-start charge |

Instant Database queries report the total number of matching agents alongside the delivered rows, so you can see how many match your filters before raising `maxItems`.

### Output Overview

Four record shapes can appear in a run:

- **Database agent** (Instant Database mode) — a flat agent row served from our pre-collected store: contact info, brokerage, license, ratings, deal stats, regions, languages.
- **Live-scraped property** — the full Redfin listing (sale/sold/rental), with all detail sections.
- **Live-scraped agent** — a flat agent profile from a live agent-directory or profile-page scrape.
- **Market summary** — one aggregate record at the end (live scrape only, when `includeMarketSummary: true`).

Free-tier users receive the first 2 Instant Database records in full as proof of data quality; every record after that has its email/phone replaced with an upgrade prompt. Paying users always receive full contact info.

### Output Samples

**Instant Database agent (shortened):**

```jsonc
{
  "agent_id": "10199",
  "name": "Karl Taylor",
  "full_name": "Karl Taylor",
  "email": "karl.taylor@redfin.com",
  "phone": "(772) 539-4128",
  "job_title": "Principal Agent",
  "office_state": "FL",
  "star_rating": 4.8,
  "num_reviews": 203,
  "past_year_deals": 25,
  "home_transactions_lifetime": 507,
  "transaction_volume_lifetime": 156343986,
  "is_premier": true,
  "is_active": true,
  "primary_service_regions": "Stuart; Hobe Sound & S. Stuart; Palm City; Jensen Beach; …",
  "business_market": "Palm Beach",
  "photo_url": "https://ssl.cdn-redfin.com/system_files/images/10199/640x460/6_2.jpg",
  "profile_url": "https://www.redfin.com/real-estate-agents/karl-taylor",
  "last_scraped_at": "2026-06-29T07:13:44.602+00:00"
}
```

**Live-scraped property (shortened):**

```jsonc
{
  "url": "https://www.redfin.com/TX/Austin/1204-2nd-Ave-NW-55912/home/64446623",
  "propertyId": 64446623,
  "mlsId": "7093054",
  "price": 134900,
  "beds": 3, "baths": 2, "sqFt": 1232, "pricePerSqFt": 109,
  "yearBuilt": 1934, "propertyType": "Single Family",
  "city": "Austin", "state": "MN", "zip": "55912",
  "latLong": { "latitude": 43.67, "longitude": -92.97 },
  "status": "Active", "daysOnMarket": 12,
  "redfinEstimate": 142000,
  "priceHistory": [ { "date": "2026-05-01", "event": "Listed", "price": 134900 } ],
  "taxInfo": { "taxableLandValue": 18000, "taxYear": 2025, "annualTax": 2160 },
  "schools": [ { "name": "Austin High", "rating": 6, "type": "public" } ],
  "climateRisk": { "flood": "Minimal", "fire": "Minor", "heat": "Moderate" },
  "walkScore": 54, "transitScore": 31, "bikeScore": 48,
  "neighborhoodStats": { "medianListPrice": 245000, "medianDom": 28 },
  "hoaDues": null,
  "photos": [ "https://ssl.cdn-redfin.com/photo/..." ]
}
```

**Live-scraped agent (shortened):**

```jsonc
{
  "agentId": "redfin-12345",
  "fullName": "Jane Doe", "email": "jane.doe@redfin.com", "phoneNumber": "+1 512-555-0100",
  "brokerageName": "Redfin Corporation", "jobTitle": "Listing Agent",
  "starRating": 4.9, "numReviews": 87,
  "totalDealsInPastYear": 34, "transactionVolumeLifetime": 41250000,
  "primaryServiceRegions": ["Austin, TX"], "languages": ["English", "Spanish"],
  "licenseNumber": "0654321", "profileUrl": "https://www.redfin.com/real-estate-agents/jane-doe"
}
```

**Market summary (when `includeMarketSummary: true`):**

```jsonc
{
  "recordType": "marketSummary",
  "totalListings": 200, "listingsWithPrice": 196,
  "price": { "median": 134900, "avg": 168540, "min": 49000, "max": 990000 },
  "pricePerSqft": { "median": 109, "avg": 121 },
  "beds": { "median": 3 }, "baths": { "median": 2 },
  "daysOnMarket": { "median": 21 },
  "byPropertyType": { "Single Family": 142, "Condo/Co-op": 38, "Multi-Family": 16 },
  "byCity": { "Austin": 200 },
  "byZip": { "55912": 73, "55901": 61 }
}
```

### Key Output Fields

| Group | Fields |
|---|---|
| **Database agent — identity & credentials** | agent\_id, name, full\_name, email, phone, job\_title, license\_number, brokerage\_name, office\_state, profile\_url, photo\_url |
| **Database agent — performance** | star\_rating, num\_reviews, past\_year\_deals, total\_deals\_in\_past\_year, home\_transactions\_lifetime, transaction\_volume\_lifetime, active\_listings\_count |
| **Database agent — coverage** | primary\_service\_regions, property\_types, neighborhoods, languages, business\_market |
| **Property identity** | url, propertyId, mlsId, address, city, state, zip, latLong |
| **Property price & status** | price, pricePerSqFt, status, daysOnMarket, soldDate, **priceHistory** |
| **Property valuation & risk** | **redfinEstimate (AVM)**, taxInfo, schools, walkScore/transitScore/bikeScore, **climateRisk** |
| **Live-scraped agent** | fullName, email, phone, brokerageName, ratings, deal counts, regions, languages, license |
| **Market summary** | median/avg/min/max price, $/sqft, beds, baths, days-on-market, breakdowns by type/city/zip |

### FAQ

#### What's the difference between Instant Database mode and live scraping?

Instant Database mode (`dbState`, `dbCity`, `dbBrokerage`, or `instantDatabase: true`) serves agents straight from our pre-collected store — no requests to Redfin, results in seconds. Live scraping (`startUrls` or `searchKeyword`) hits Redfin directly for current listings or a specific agent-directory page.

#### Are all the database agents Redfin's own employees?

No. The database is a mix of Redfin's in-house agents and the partner/external brokerage agents (Compass, NextHome, and others) that appear on Redfin's public agent-directory pages. Use `dbBrokerage` to filter to a specific brokerage.

#### Do I need a Redfin URL for Instant Database mode?

No — just set a state (and optionally city/brokerage) in the Instant Database fields and leave `startUrls` empty.

#### Does it scrape sold listings and rentals, not just for-sale?

Yes — set `searchMode` to `sale`, `sold`, or `rental`. Use `soldTimeframe` to control the sold-comps window.

#### Can I get more than 350 results from a city search?

Yes. Redfin caps a single search at roughly 350 homes; this actor tiles the map to pull the full result set.

#### Does it really include price history, tax, schools and climate risk?

Yes — those sections are captured in every live-scraped property row. Use the `includes*` toggles to drop any sections you don't need and shrink the output.

#### How do I get agent emails from a live scrape instead of the database?

Point `startUrls` at a Redfin agent-directory or profile page. Each agent row includes the contact info Redfin exposes on that page; enable `enrichEmails` for a best-effort lookup when Redfin doesn't expose one directly.

#### Why is a property row so large?

It faithfully mirrors Redfin's full listing data. Set `flattenOutput: true` for a flatter shape, or disable detail sections with the `includes*` toggles.

#### Can I scrape private profiles or content behind a login?

No. The actor only accesses publicly available pages — Redfin's agent directories, property listings, and search results.

#### JSON or CSV?

Both — export from your Apify dataset in whichever format you need.

### Support

Found a bug or want a field added? Open an issue on the actor's **Issues** tab and we'll take a look.

### Additional Services

Need a custom real-estate feed (other portals, scheduled monitoring, a webhook/Sheets/DB push, or a tailored schema)? Reach out — custom scraping and data-pipeline work is available.

### Explore More Scrapers

- [Realtor.com Scraper](https://apify.com/memo23/realtor-search-cheerio) — 200,000+ agent instant database, plus search · detail · agents
- [Zillow Agents & Leads Scraper](https://apify.com/memo23/zillow-agents-leads-scraper-ppe) — 373,000+ agent instant database
- [Redfin Property Scraper (rental)](https://apify.com/memo23/apify-redfin-cheerio) — property-only, flat monthly pricing
- [LoopNet Scraper](https://apify.com/memo23/loopnet-scraper-ppe) — US + UK commercial property
- [Rightmove Scraper](https://apify.com/memo23/rightmove-scraper) — UK buy / rent / sell

See the [full memo23 actor catalog →](https://apify.com/memo23)

### ⚠️ Disclaimer

This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Redfin Corporation or any of its subsidiaries. All trademarks mentioned are the property of their respective owners.

The scraper accesses only publicly available Redfin.com pages and pre-collected public agent-directory data — no authenticated endpoints, paid features, or content behind Redfin's login wall. Users are responsible for ensuring their use complies with Redfin's Terms of Service, applicable data-protection law (GDPR, CCPA, etc.), and any contractual obligations of their own organization.

### SEO Keywords

redfin scraper, redfin.com scraper, redfin api, redfin agent database, redfin agent email database, redfin agent scraper, real estate agent emails, real estate lead generation, property listings scraper, sold listings scraper, rental listings scraper, redfin estimate scraper, property price history, real estate market data, climate risk data, housing market scraper, mls data scraper, redfin bulk export, comparable sales data, property tax data, redfin json csv export, real estate market summary, brokerage roster scraper

# Actor input Schema

## `dbState` (type: `string`):

The US state to pull agents for — e.g. FL, CA, TX. Setting this alone delivers instant database results.

## `dbCity` (type: `string`):

Narrow to a city or service region (case-insensitive substring). Leave empty to return the whole state.

## `dbBrokerage` (type: `string`):

Only return agents whose brokerage name contains this text (case-insensitive), e.g. "Redfin" or "Compass".

## `dbHasEmail` (type: `boolean`):

Return only agents that have an email address on file.

## `dbHasPhone` (type: `boolean`):

Return only agents that have a phone number on file.

## `instantDatabase` (type: `boolean`):

Serve results from the pre-collected database instead of live-scraping. Auto-enabled when you set a State / City / Brokerage above.

## `startUrls` (type: `array`):

URLs to start with. Optional when using searchKeyword + searchMode.

## `searchKeyword` (type: `string`):

Optional Redfin search phrase such as a city, ZIP code, or neighborhood. When set, the actor resolves it through Redfin autocomplete before crawling.

## `searchMode` (type: `string`):

Mode used with searchKeyword.

## `soldTimeframe` (type: `string`):

Sold-history window used when searchMode is sold.

## `flattenOutput` (type: `boolean`):

Set to true to output a flat data structure.

## `includesAboveTheFoldData` (type: `boolean`):

Include address, basic region info, and media.

## `includesBelowTheFoldData` (type: `boolean`):

Include neighborhood, transit, and schools.

## `includesParcelBounds` (type: `boolean`):

Include property boundaries and APN data.

## `includesBannerData` (type: `boolean`):

Include current promotions or banners.

## `includesAmenitiesData` (type: `boolean`):

Include community and unit amenities.

## `includesWalkScoreData` (type: `boolean`):

Include walk, transit, and bike scores.

## `includesSellsideThresholdData` (type: `boolean`):

Include price drop info.

## `includesFloorPlansData` (type: `boolean`):

Include bed/bath units and floor plan structures.

## `includesProtoHomeData` (type: `boolean`):

Include companion Redfin proto-home enrichment when available.

## `includeProfileDetails` (type: `boolean`):

Include detailed profile information in the output.

## `enrichEmails` (type: `boolean`):

If enabled, finds a contact email for each result from its own website (or by discovering it from the name). Adds contactEmail + contactWebsite columns plus a detailed emailEnrichment object. Best-effort.

## `includeMarketSummary` (type: `boolean`):

When enabled, appends ONE extra summary record at the end of the run with market analytics computed across all scraped listings: total count, median / average / min / max price, median price-per-sqft, median beds & baths, median days-on-market, and counts broken down by property type, city and zip. Great for market tracking and valuation benchmarking. Computed from data already scraped — no extra requests.

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

Maximum number of listings/items that will be scraped.

## `maxConcurrency` (type: `integer`):

Maximum number of pages that can be processed at the same time.

## `minConcurrency` (type: `integer`):

Minimum number of pages that will be processed at the same time.

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

Number of times the crawler will retry a failed request before giving up.

## `storeName` (type: `string`):

Assign a custom name to the Key-Value Store where your scraped listings will be saved. This ensures:

1. **Data Deduplication**: Prevents duplicate entries in the storage.
2. **Persistent Storage**: Enables long-term retention of listings, beyond default storage limits.
3. **Project Management**: Separate datasets by using unique names for different projects or analyses.
4. **Data Reuse**: Easily reference and reuse stored data without overwriting.
   (If left blank, the default storage will be used with standard retention limits.)

## `proxy` (type: `object`):

Specifies proxy servers that will be used by the scraper in order to hide its origin.<br><br>For details, see <a href='https://apify.com/apify/web-scraper#proxy-configuration' target='_blank' rel='noopener'>Proxy configuration</a> in README.

## Actor input object example

```json
{
  "dbHasEmail": false,
  "dbHasPhone": false,
  "instantDatabase": false,
  "startUrls": [
    "https://www.redfin.com/neighborhood/290650/CA/Los-Angeles/Westchester/apartments-for-rent"
  ],
  "searchMode": "sale",
  "soldTimeframe": "1mo",
  "flattenOutput": false,
  "includesAboveTheFoldData": true,
  "includesBelowTheFoldData": true,
  "includesParcelBounds": true,
  "includesBannerData": true,
  "includesAmenitiesData": true,
  "includesWalkScoreData": true,
  "includesSellsideThresholdData": true,
  "includesFloorPlansData": true,
  "includesProtoHomeData": true,
  "includeProfileDetails": false,
  "enrichEmails": false,
  "includeMarketSummary": false,
  "maxItems": 1000,
  "maxConcurrency": 50,
  "minConcurrency": 1,
  "maxRequestRetries": 100,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "startUrls": [
        "https://www.redfin.com/neighborhood/290650/CA/Los-Angeles/Westchester/apartments-for-rent"
    ],
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/apify-redfin-cheerio-ppe").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 = {
    "startUrls": ["https://www.redfin.com/neighborhood/290650/CA/Los-Angeles/Westchester/apartments-for-rent"],
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("memo23/apify-redfin-cheerio-ppe").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    "https://www.redfin.com/neighborhood/290650/CA/Los-Angeles/Westchester/apartments-for-rent"
  ],
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call memo23/apify-redfin-cheerio-ppe --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=memo23/apify-redfin-cheerio-ppe",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Redfin Scraper — Listings + Agent Database (Email & Phone)",
        "description": "Redfin scraper with an instant agent database — 10,800+ agents, all 50 states, email + phone + deal stats, uncapped. Filter by State/City/Brokerage, no scraping needed. Or live-scrape search URLs, property details, agents & emails across sale, sold & rental. Pure HTTP. JSON/CSV.",
        "version": "0.0",
        "x-build-id": "oRBjcklVUbMyvoIqE"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/memo23~apify-redfin-cheerio-ppe/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-memo23-apify-redfin-cheerio-ppe",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/memo23~apify-redfin-cheerio-ppe/runs": {
            "post": {
                "operationId": "runs-sync-memo23-apify-redfin-cheerio-ppe",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/memo23~apify-redfin-cheerio-ppe/run-sync": {
            "post": {
                "operationId": "run-sync-memo23-apify-redfin-cheerio-ppe",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "dbState": {
                        "title": "State (2-letter code)",
                        "type": "string",
                        "description": "The US state to pull agents for — e.g. FL, CA, TX. Setting this alone delivers instant database results."
                    },
                    "dbCity": {
                        "title": "City / region (optional)",
                        "type": "string",
                        "description": "Narrow to a city or service region (case-insensitive substring). Leave empty to return the whole state."
                    },
                    "dbBrokerage": {
                        "title": "Brokerage contains (optional)",
                        "type": "string",
                        "description": "Only return agents whose brokerage name contains this text (case-insensitive), e.g. \"Redfin\" or \"Compass\"."
                    },
                    "dbHasEmail": {
                        "title": "Only agents with an email",
                        "type": "boolean",
                        "description": "Return only agents that have an email address on file.",
                        "default": false
                    },
                    "dbHasPhone": {
                        "title": "Only agents with a phone",
                        "type": "boolean",
                        "description": "Return only agents that have a phone number on file.",
                        "default": false
                    },
                    "instantDatabase": {
                        "title": "Use Instant Database (no scraping)",
                        "type": "boolean",
                        "description": "Serve results from the pre-collected database instead of live-scraping. Auto-enabled when you set a State / City / Brokerage above.",
                        "default": false
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "URLs to start with. Optional when using searchKeyword + searchMode.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchKeyword": {
                        "title": "Search keyword (e.g. Los Angeles)",
                        "type": "string",
                        "description": "Optional Redfin search phrase such as a city, ZIP code, or neighborhood. When set, the actor resolves it through Redfin autocomplete before crawling."
                    },
                    "searchMode": {
                        "title": "Search Mode",
                        "enum": [
                            "sale",
                            "rent",
                            "sold"
                        ],
                        "type": "string",
                        "description": "Mode used with searchKeyword.",
                        "default": "sale"
                    },
                    "soldTimeframe": {
                        "title": "Sold Timeframe",
                        "enum": [
                            "1mo",
                            "3mo",
                            "6mo",
                            "1yr"
                        ],
                        "type": "string",
                        "description": "Sold-history window used when searchMode is sold.",
                        "default": "1mo"
                    },
                    "flattenOutput": {
                        "title": "Flatten Output Structure",
                        "type": "boolean",
                        "description": "Set to true to output a flat data structure.",
                        "default": false
                    },
                    "includesAboveTheFoldData": {
                        "title": "Includes Above The Fold Data",
                        "type": "boolean",
                        "description": "Include address, basic region info, and media.",
                        "default": true
                    },
                    "includesBelowTheFoldData": {
                        "title": "Includes Below The Fold Data",
                        "type": "boolean",
                        "description": "Include neighborhood, transit, and schools.",
                        "default": true
                    },
                    "includesParcelBounds": {
                        "title": "Includes Parcel Bounds",
                        "type": "boolean",
                        "description": "Include property boundaries and APN data.",
                        "default": true
                    },
                    "includesBannerData": {
                        "title": "Includes Banner Data",
                        "type": "boolean",
                        "description": "Include current promotions or banners.",
                        "default": true
                    },
                    "includesAmenitiesData": {
                        "title": "Includes Amenities Data",
                        "type": "boolean",
                        "description": "Include community and unit amenities.",
                        "default": true
                    },
                    "includesWalkScoreData": {
                        "title": "Includes Walk Score Data",
                        "type": "boolean",
                        "description": "Include walk, transit, and bike scores.",
                        "default": true
                    },
                    "includesSellsideThresholdData": {
                        "title": "Includes Sellside Threshold Data",
                        "type": "boolean",
                        "description": "Include price drop info.",
                        "default": true
                    },
                    "includesFloorPlansData": {
                        "title": "Includes Floor Plans Data",
                        "type": "boolean",
                        "description": "Include bed/bath units and floor plan structures.",
                        "default": true
                    },
                    "includesProtoHomeData": {
                        "title": "Includes Proto Home Data",
                        "type": "boolean",
                        "description": "Include companion Redfin proto-home enrichment when available.",
                        "default": true
                    },
                    "includeProfileDetails": {
                        "title": "Include Profile Details",
                        "type": "boolean",
                        "description": "Include detailed profile information in the output.",
                        "default": false
                    },
                    "enrichEmails": {
                        "title": "Enrich with contact emails (experimental)",
                        "type": "boolean",
                        "description": "If enabled, finds a contact email for each result from its own website (or by discovering it from the name). Adds contactEmail + contactWebsite columns plus a detailed emailEnrichment object. Best-effort.",
                        "default": false
                    },
                    "includeMarketSummary": {
                        "title": "Add a market summary record",
                        "type": "boolean",
                        "description": "When enabled, appends ONE extra summary record at the end of the run with market analytics computed across all scraped listings: total count, median / average / min / max price, median price-per-sqft, median beds & baths, median days-on-market, and counts broken down by property type, city and zip. Great for market tracking and valuation benchmarking. Computed from data already scraped — no extra requests.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max number of listings/items per crawl/scrape",
                        "type": "integer",
                        "description": "Maximum number of listings/items that will be scraped.",
                        "default": 1000
                    },
                    "maxConcurrency": {
                        "title": "Max Concurrency",
                        "type": "integer",
                        "description": "Maximum number of pages that can be processed at the same time.",
                        "default": 50
                    },
                    "minConcurrency": {
                        "title": "Min Concurrency",
                        "type": "integer",
                        "description": "Minimum number of pages that will be processed at the same time.",
                        "default": 1
                    },
                    "maxRequestRetries": {
                        "title": "Max Request Retries",
                        "type": "integer",
                        "description": "Number of times the crawler will retry a failed request before giving up.",
                        "default": 100
                    },
                    "storeName": {
                        "title": "Name your storage for listings (deduplication and long-term retention)",
                        "type": "string",
                        "description": "Assign a custom name to the Key-Value Store where your scraped listings will be saved. This ensures:\n 1. **Data Deduplication**: Prevents duplicate entries in the storage. \n 2. **Persistent Storage**: Enables long-term retention of listings, beyond default storage limits.\n 3. **Project Management**: Separate datasets by using unique names for different projects or analyses.\n 4. **Data Reuse**: Easily reference and reuse stored data without overwriting.\n (If left blank, the default storage will be used with standard retention limits.)"
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Specifies proxy servers that will be used by the scraper in order to hide its origin.<br><br>For details, see <a href='https://apify.com/apify/web-scraper#proxy-configuration' target='_blank' rel='noopener'>Proxy configuration</a> in README.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
