# Redfin Scraper - Real Estate Listings, Prices & Property Data (`bujhmml/redfin-real-estate-scraper`) Actor

Scrape Redfin homes for sale, rentals, and recently sold: prices, beds, baths, sqft, $/sqft, lot, HOA, address, coordinates, MLS id, description, and full-size photo URLs. Fast, HTTP-first, runs on datacenter proxies.

- **URL**: https://apify.com/bujhmml/redfin-real-estate-scraper.md
- **Developed by:** [Ihor Bielievskiy](https://apify.com/bujhmml) (community)
- **Categories:** Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.40 / 1,000 listings

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/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 - Real Estate Listings, Prices & Property Data

Give it a Redfin search URL (a city, zipcode, neighborhood, or county) and get back clean, structured data: homes for sale, rentals, or recently sold, with prices, beds and baths, square footage, lot size, HOA, the full address and coordinates, MLS id, the listing text, and direct links to every photo. Export as JSON, CSV, or Excel.

It calls Redfin's own search API directly instead of driving a headless browser, so it's quick and runs fine on cheap datacenter proxies. You don't need residential.

### What it can scrape

Set `listingType`:

- **`for_sale`** — active and coming-soon listings (the default)
- **`rentals`** — rentals, with rent ranges, how many units are available, and the leasing contact
- **`sold`** — recently sold homes with the sale date and price; use `soldWithinDays` to pick the window

Drop one or more search URLs into `startUrls`. The URL only decides *which area* gets scraped. Any price/bed/`/filter/` parts in it are ignored, so set those through the inputs below instead.

### Fields (for-sale)

`price`, `beds`, `baths`, `sqft`, `price_per_sqft`, `lot_size`, `hoa`, `year_built`, `property_type`, `is_new_construction`, `street`, `unit`, `city`, `state`, `zip_code`, `latitude`, `longitude`, `days_on_market`, `mls_id`, `mls_status`, `description`, `key_facts`, `listing_tags`, `badges`, `open_house`, `photos_count`, `photo_urls`, `url` (plus `property_id` / `listing_id`).

Rentals and sold return their own fields: rent ranges, available units and a contact for rentals; sale date, sold price and status for sold.

### Input

| Field | Description |
|-------|-------------|
| `startUrls` | Redfin city / zipcode / neighborhood / county search URLs. |
| `listingType` | `for_sale`, `rentals`, or `sold`. |
| `soldWithinDays` | For `sold`: how far back to look (Redfin caps the export at ~350 per URL). |
| `maxItems` | Stop after this many results across all URLs (0 = no limit). |
| `sort` | `recommended`, `price_low_high`, or `price_high_low`. |
| `propertyTypes` | House / Condo / Townhouse / Multi-family / Land / Other. |
| `proxyConfiguration` | Apify Proxy — datacenter is enough. |
| `impersonate` | Browser TLS fingerprint (`chrome` by default). |

```json
{
  "startUrls": [{ "url": "https://www.redfin.com/city/17151/CA/San-Francisco" }],
  "listingType": "for_sale",
  "maxItems": 500,
  "sort": "price_low_high"
}
````

### Example output

```json
{
  "street": "1515 Underwood Ave",
  "city": "San Francisco",
  "state": "CA",
  "price": 895000.0,
  "beds": 3.0,
  "baths": 1.5,
  "sqft": 1500,
  "price_per_sqft": 597.0,
  "days_on_market": 1,
  "mls_status": "Active",
  "latitude": 37.72,
  "longitude": -122.39,
  "badges": ["Open House"],
  "open_house": ["OPEN SAT, 1PM TO 4PM"],
  "photos_count": 38,
  "photo_urls": [
    "https://ssl.cdn-redfin.com/photo/9/bigphoto/164/426141164_1.jpg",
    "https://ssl.cdn-redfin.com/photo/9/bigphoto/164/426141164_1_1.jpg"
  ],
  "url": "https://www.redfin.com/CA/San-Francisco/1515-Underwood-Ave-94124/home/1543331"
}
```

### Photos

Every listing comes with `photo_urls`: direct links to the full-size images on Redfin's CDN. They're built from the listing data itself, so there's no extra request per home and no residential proxy needed. `photos_count` tells you how many to expect.

### A few things worth knowing

- **Sold is capped at ~350 homes per URL.** That's Redfin's own limit on the sold export, not the actor. For a busy area, scrape it by zipcode or use a shorter `soldWithinDays`.
- **Nothing fails silently.** If an area gets blocked or a request fails, you get a typed error row for it, so an empty result always means "nothing found" and never a hidden block.
- **You're billed per valid result delivered**, so error rows and duplicates don't cost you anything.

### Roadmap

Per-home detail (price history, tax records, schools, the Redfin Estimate) sits behind heavier protection than the search API, so it needs a different approach. It's planned as an optional add-on rather than something bolted on half-working.

### Notes

Only public, unauthenticated Redfin pages are scraped. The data comes from Redfin's public site, so follow Redfin's Terms and the laws that apply to you, and use it responsibly. Removal requests are honored.

### Who built this

I build scrapers for my own projects and publish the ones that turn out genuinely useful. This is one of them. If you need a custom scraper, a data pipeline, or a change to this actor, I'm available for freelance work.

GitHub: [github.com/bujhmml](https://github.com/bujhmml) · Site: [bujhmml.fun](https://bujhmml.fun)

# Actor input Schema

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

Redfin city / zipcode / neighborhood / county search-result URLs (paste what you see in the browser address bar). Choose For sale / Rentals / Sold with the Listing type option below. URL path filters (price, beds, /filter/, /sold) are ignored — control results with the inputs here instead.

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

Scrape homes for sale, rentals, or recently sold.

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

For Listing type = Sold: how far back to look, in days (e.g. 7, 30, 90, 365). Sold export is capped at 350 homes per URL; use a smaller region or shorter window for complete coverage.

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

Stop after this many results across all URLs. 0 = no limit.

## `sort` (type: `string`):

Order in which Redfin returns listings.

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

Which property types to include.

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

Apify Proxy. Datacenter is usually enough for Redfin's listing API.

## `impersonate` (type: `string`):

curl\_cffi impersonation target used for requests.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.redfin.com/city/17151/CA/San-Francisco"
    }
  ],
  "listingType": "for_sale",
  "soldWithinDays": 90,
  "maxItems": 100,
  "sort": "recommended",
  "propertyTypes": [
    "1",
    "2",
    "3",
    "4",
    "5",
    "6"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "impersonate": "chrome"
}
```

# 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": [
        {
            "url": "https://www.redfin.com/city/17151/CA/San-Francisco"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("bujhmml/redfin-real-estate-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 = { "startUrls": [{ "url": "https://www.redfin.com/city/17151/CA/San-Francisco" }] }

# Run the Actor and wait for it to finish
run = client.actor("bujhmml/redfin-real-estate-scraper").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": [
    {
      "url": "https://www.redfin.com/city/17151/CA/San-Francisco"
    }
  ]
}' |
apify call bujhmml/redfin-real-estate-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Redfin Scraper - Real Estate Listings, Prices & Property Data",
        "description": "Scrape Redfin homes for sale, rentals, and recently sold: prices, beds, baths, sqft, $/sqft, lot, HOA, address, coordinates, MLS id, description, and full-size photo URLs. Fast, HTTP-first, runs on datacenter proxies.",
        "version": "1.0",
        "x-build-id": "RnAhEj1ynqVVySed4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/bujhmml~redfin-real-estate-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-bujhmml-redfin-real-estate-scraper",
                "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/bujhmml~redfin-real-estate-scraper/runs": {
            "post": {
                "operationId": "runs-sync-bujhmml-redfin-real-estate-scraper",
                "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/bujhmml~redfin-real-estate-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-bujhmml-redfin-real-estate-scraper",
                "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",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Redfin search URLs",
                        "type": "array",
                        "description": "Redfin city / zipcode / neighborhood / county search-result URLs (paste what you see in the browser address bar). Choose For sale / Rentals / Sold with the Listing type option below. URL path filters (price, beds, /filter/, /sold) are ignored — control results with the inputs here instead.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "listingType": {
                        "title": "Listing type",
                        "enum": [
                            "for_sale",
                            "rentals",
                            "sold"
                        ],
                        "type": "string",
                        "description": "Scrape homes for sale, rentals, or recently sold.",
                        "default": "for_sale"
                    },
                    "soldWithinDays": {
                        "title": "Sold within days",
                        "minimum": 1,
                        "type": "integer",
                        "description": "For Listing type = Sold: how far back to look, in days (e.g. 7, 30, 90, 365). Sold export is capped at 350 homes per URL; use a smaller region or shorter window for complete coverage.",
                        "default": 90
                    },
                    "maxItems": {
                        "title": "Max results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Stop after this many results across all URLs. 0 = no limit.",
                        "default": 100
                    },
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "recommended",
                            "price_low_high",
                            "price_high_low"
                        ],
                        "type": "string",
                        "description": "Order in which Redfin returns listings.",
                        "default": "recommended"
                    },
                    "propertyTypes": {
                        "title": "Property types",
                        "type": "array",
                        "description": "Which property types to include.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "1",
                                "2",
                                "3",
                                "4",
                                "5",
                                "6"
                            ],
                            "enumTitles": [
                                "House",
                                "Condo",
                                "Townhouse",
                                "Multi-family",
                                "Land",
                                "Other"
                            ]
                        },
                        "default": [
                            "1",
                            "2",
                            "3",
                            "4",
                            "5",
                            "6"
                        ]
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Apify Proxy. Datacenter is usually enough for Redfin's listing API.",
                        "default": {
                            "useApifyProxy": true
                        }
                    },
                    "impersonate": {
                        "title": "Browser TLS fingerprint",
                        "enum": [
                            "chrome",
                            "chrome131",
                            "chrome124",
                            "safari17_0"
                        ],
                        "type": "string",
                        "description": "curl_cffi impersonation target used for requests.",
                        "default": "chrome"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
