# Redfin Property Scraper - Homes for Sale, Rent, and Sold Data (`cirkit/redfin-property-scraper`) Actor

Fast, low-cost Redfin scraper for homes for sale, rentals, sold, coming-soon, and pending listings. Returns 50+ fields per home (price, beds, baths, sqft, lat/long, photos, MLS, key facts) with rich filters. 350 results per request.

- **URL**: https://apify.com/cirkit/redfin-property-scraper.md
- **Developed by:** [Crikit](https://apify.com/cirkit) (community)
- **Categories:** Real estate
- **Stats:** 15 total users, 4 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.35 / 1,000 results

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Redfin Property Scraper - Homes for Sale, Rent, and Sold Data

**Scrape Redfin listings** across every status Redfin publishes: for sale, for rent, sold, coming soon, and pending. This **Redfin scraper** returns 50+ fields per home — price, beds, baths, square footage, lot size, year built, coordinates, MLS number, days on market, and broker — with rich server-side filtering and up to 350 results per request.

No Redfin API key, no login, and no headless browser. Results land in a structured dataset you can export to JSON, CSV, Excel, or XML, or pull straight from the Apify API.

### What is Redfin Property Scraper - Homes for Sale, Rent, and Sold Data?

Redfin Property Scraper - Homes for Sale, Rent, and Sold Data is an [Apify Actor](https://apify.com/actors) that extracts homes for sale, rent, sold, and coming soon from [Redfin](https://www.redfin.com) and returns them as clean, structured records. Sold data is the differentiator: Redfin publishes closed sale prices and dates, which makes this one of the few public sources for real transaction comps rather than asking prices.

### What data can this Redfin scraper extract?

Every run writes one row per home. The full schema carries **46 fields**; the most-used ones are below.

| Field | Type | Description |
| --- | --- | --- |
| `propertyId` | integer | Redfin internal property ID. Stable across listings (a property keeps the same propertyId when relisted). |
| `listingId` | integer | Redfin internal listing ID. Unique per listing instance. |
| `homeUrl` | string | Absolute URL to the property page on redfin.com. |
| `mlsNumber` | string | MLS listing number as reported by the source MLS. |
| `mlsStatus` | string | Raw MLS status string from the source MLS (e.g. Active, Pending, Sold). |
| `listingStatus` | string | Human-readable listing status decoded from Redfin's searchStatus code. |
| `listingTypeName` | string | Human-readable listing type decoded from Redfin's listingType code (For Sale, Sold, Rental, etc.). |
| `propertyTypeName` | string | Human-readable property type decoded from Redfin's uiPropertyType code (Single Family Home, Condo, Townhouse, etc.). |
| `priceUsd` | number | List price or sold price in USD. |
| `pricePerSqFtUsd` | number | Price per square foot in USD. |
| `hoaUsd` | number | HOA dues per Redfin's reported cadence (typically monthly), in USD. |
| `sqFt` | integer | Livable square footage of the home. |
| `lotSizeSqFt` | integer | Lot size in square feet. |
| `beds` | integer | Bedroom count. |
| `baths` | number | Total bathroom count (half baths count as 0.5). |
| `fullBaths` | integer | Number of full bathrooms. |
| `partialBaths` | integer | Number of half or partial bathrooms. |
| `yearBuilt` | integer | Year the property was built. |
| `addressFull` | string | Comma-joined full address (street + unit, city, state zip). |
| `streetLine` | string | Street address line including house number. |
| `unitNumber` | string | Unit, apartment, or suite designator when present. |
| `city` | string | City name. |

See the **Output** tab in Apify Console for all 46 fields.

### How to scrape Redfin property listings

1. Open [Redfin Property Scraper - Homes for Sale, Rent, and Sold Data](https://apify.com/cirkit/redfin-property-scraper) and click **Try for free**.
2. Paste Redfin search URLs into `searchUrls`, or give plain place names in `searches`.
3. Pick `listingType` — for sale, rented, sold, coming soon, or pending.
4. Filter server-side with `minPrice`, `maxPrice`, `minBeds`, `minSqft`, `minYearBuilt`, and `hasGarage`.
5. For sold comps, set `soldWithinDays` to the lookback window you need.
6. Click **Start** and watch rows appear live in the **Output** tab.
7. Export the dataset as JSON, CSV, Excel, or XML — or fetch it from the [Apify API](https://docs.apify.com/api/v2) once the run finishes.

### Redfin Property Scraper - Homes for Sale, Rent, and Sold Data input options

| Input | Type | What it does | Default |
| --- | --- | --- | --- |
| `searchUrls` | array | Redfin URLs for a city, zip code, county, or neighborhood. Each URL is scraped page by page (up to maxPagesPerRegion). | `see schema` |
| `searches` | array | Additional regions to scrape. Each item can be a 5-digit U.S. zip code string (e.g. "10001") or a structured object... |  |
| `listingType` | string | Which listing status to scrape. | `"forSale"` |
| `sortBy` | string | Sort order for search results, applied via Redfin's 'ord' parameter. | `"redfinRecommended"` |
| `propertyTypes` | array | Filter listings to the selected property types. | `see schema` |
| `minPrice` | integer | Filter listings priced at or above this USD value. |  |
| `maxPrice` | integer | Filter listings priced at or below this USD value. |  |
| `minBeds` | integer | Minimum number of bedrooms. |  |
| `minBaths` | integer | Minimum number of bathrooms. |  |
| `minSqft` | integer | Minimum livable square footage. |  |
| `maxSqft` | integer | Maximum livable square footage. |  |
| `minYearBuilt` | integer | Minimum year built. |  |
| `maxYearBuilt` | integer | Maximum year built. |  |
| `hasGarage` | boolean | Only homes that report a garage. | `false` |
| `soldWithinDays` | integer | Sold within N days (only when listingType=sold). |  |
| `maxItems` | integer | Hard cap across all regions combined. | `50` |

Proxy is configured through the standard `proxyConfiguration` object; the defaults shipped with this Actor are already tuned for the target site.

### Example output

```json
{
    "searchUrls": [
        { "url": "https://www.redfin.com/city/30749/NY/New-York" }
    ],
    "listingType": "forSale",
    "sortBy": "newest",
    "minPrice": 500000,
    "maxPrice": 2000000,
    "minBeds": 2,
    "maxItems": 1000
}
```

### How much does it cost to scrape Redfin?

This Actor runs on **pay per result** pricing: **$0.00035 per home** ($0.35 per 1,000). A one-time start fee of $0.00005 applies per run.

| Results | Approximate cost |
| --- | --- |
| 1,000 | $0.35 |
| 10,000 | $3.50 |
| 100,000 | $35.00 |

You pay for rows you actually receive, so a search that returns nothing costs nothing beyond the start fee. Every Apify account includes free monthly usage credit, so you can trial Redfin Property Scraper - Homes for Sale, Rent, and Sold Data at no cost.

### What can you build with Redfin data?

#### Pull real sold comps for an appraisal or offer

`soldDateIso` and the sold price give you closed-transaction comps, which carry far more weight than active list prices when pricing an offer.

#### Track days-on-market across a submarket

`daysOnRedfin` aggregated by ZIP and price band is one of the fastest reads on whether a local market is tightening or softening.

#### Catch coming-soon inventory before it lists

The coming-soon status surfaces homes days before they hit the active market — a real edge for buyer agents and investors.

#### Feed an investment screening model

Price per square foot, HOA, lot size, and year built together let you filter thousands of homes down to a shortlist automatically.

#### Compare Redfin and Zillow coverage

Running the same market through both catches listings that appear on one portal and not the other.

### Redfin scraping tips and limits

- Redfin returns up to 350 results per request, which is more generous than most portals — but a large metro still needs splitting by region or price band for full coverage.
- `listingType` changes which fields are populated. Sold rows carry sale price and date; active rows do not.
- Use `flattenFields` when you want a CSV-friendly shape rather than nested objects.
- This is among the cheapest per-row real-estate Actors in the fleet, so broad sweeps are affordable — but set `maxItems` on a first run to learn the market size.

### Integrations and automation

Run Redfin Property Scraper - Homes for Sale, Rent, and Sold Data on a [schedule](https://docs.apify.com/platform/schedules) to keep a Redfin dataset fresh, or trigger it from your own stack through the [Apify API](https://docs.apify.com/api/v2) and the official [JavaScript](https://docs.apify.com/sdk/js) and [Python](https://docs.apify.com/sdk/python) clients. Native [integrations](https://docs.apify.com/platform/integrations) push results into Google Sheets, Slack, Airtable, Zapier, Make, GitHub, or any webhook endpoint. The Actor also works as an [MCP](https://docs.apify.com/platform/integrations/mcp) tool, so an AI agent can call it directly.

### Related scrapers

| Actor | What it does |
| --- | --- |
| [Zillow Search Scraper](https://apify.com/cirkit/zillow-search-scraper) | The same market on Zillow. |
| [Zillow Detail Scraper](https://apify.com/cirkit/zillow-detail-scraper) | Deep per-property enrichment including tax and price history. |
| [Realtor.com Property Scraper (Search + Detail)](https://apify.com/cirkit/realtor-property-scraper) | Realtor.com search and detail in one Actor. |
| [Apartments.com Listings Scraper](https://apify.com/cirkit/apartments-listings-scraper) | Dedicated rental inventory from Apartments.com. |

### Frequently asked questions

#### Can I get sold home prices from Redfin?

Yes. Set `listingType` to sold and use `soldWithinDays` to control the lookback. Rows come back with the closed sale price and sold date, which is what makes Redfin valuable for comps.

#### Does it include MLS numbers?

Yes, `mlsNumber` and `mlsStatus` are on every row where Redfin publishes them, which makes reconciliation against an MLS feed straightforward.

#### Do I need a Redfin API key?

No. Redfin Property Scraper - Homes for Sale, Rent, and Sold Data reads publicly available Redfin pages and endpoints directly, so there is no key to obtain, no OAuth app to register, and no account to connect.

#### Can I export Redfin data to CSV, Excel, or Google Sheets?

Yes. Every run stores results in an Apify dataset that exports to JSON, JSONL, CSV, Excel, XML, or HTML with one click, and the Google Sheets integration writes rows straight into a spreadsheet.

#### Can I run Redfin Property Scraper - Homes for Sale, Rent, and Sold Data on a schedule?

Yes. Apify schedules run the Actor hourly, daily, weekly, or on any cron expression, and webhooks can notify your systems the moment a run finishes.

#### Is it legal to scrape Redfin?

Scraping publicly available data is broadly lawful in the US and EU, but the answer depends on what you collect and how you use it. This Actor is built to gather public property listing information Redfin publishes publicly, including broker and agent names. Personal data carries extra obligations under GDPR and CCPA. Read Apify's guide on [whether web scraping is legal](https://blog.apify.com/is-web-scraping-legal/) and take your own legal advice for your use case.

### Support and feedback

Found a bug, a missing field, or a Redfin page shape this Actor does not handle yet? Open an issue from the **Issues** tab on the Actor page. Feature requests and custom-scraper enquiries are welcome there too.

# Actor input Schema

## `searchUrls` (type: `array`):

Redfin URLs for a city, zip code, county, or neighborhood. Each URL is scraped page by page (up to maxPagesPerRegion).

## `searches` (type: `array`):

Additional regions to scrape. Each item can be a 5-digit U.S. zip code string (e.g. "10001") or a structured object {regionId, regionType, market} where regionType is 6=city, 5=county, 2=zip, 1=neighborhood. For free-text city names, paste the Redfin URL into searchUrls instead.

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

Which listing status to scrape.

## `sortBy` (type: `string`):

Sort order for search results, applied via Redfin's 'ord' parameter.

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

Filter listings to the selected property types.

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

Filter listings priced at or above this USD value.

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

Filter listings priced at or below this USD value.

## `minBeds` (type: `integer`):

Minimum number of bedrooms.

## `minBaths` (type: `integer`):

Minimum number of bathrooms.

## `minSqft` (type: `integer`):

Minimum livable square footage.

## `maxSqft` (type: `integer`):

Maximum livable square footage.

## `minYearBuilt` (type: `integer`):

Minimum year built.

## `maxYearBuilt` (type: `integer`):

Maximum year built.

## `hasGarage` (type: `boolean`):

Only homes that report a garage.

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

Sold within N days (only when listingType=sold).

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

Hard cap across all regions combined.

## `maxPagesPerRegion` (type: `integer`):

Each page returns up to 350 homes. Redfin caps the API at ~3150 homes per region.

## `flattenFields` (type: `boolean`):

When true, returns a clean flat record with derived fields (homeUrl, priceUsd, photoUrls, etc.). When false, returns the raw Redfin object.

## `includePhotoUrls` (type: `boolean`):

Decode the compressed photos field into a list of full CDN URLs.

## `includeRaw` (type: `boolean`):

When true, attaches the original Redfin home object under raw.

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

Proxy configuration.

## Actor input object example

```json
{
  "searchUrls": [
    {
      "url": "https://www.redfin.com/city/30749/NY/New-York"
    }
  ],
  "searches": [],
  "listingType": "forSale",
  "sortBy": "redfinRecommended",
  "propertyTypes": [
    "house",
    "condo",
    "townhouse",
    "multiFamily",
    "land",
    "mobile",
    "coop",
    "other"
  ],
  "hasGarage": false,
  "maxItems": 50,
  "maxPagesPerRegion": 9,
  "flattenFields": true,
  "includePhotoUrls": true,
  "includeRaw": false,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  }
}
```

# 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 = {
    "searchUrls": [
        {
            "url": "https://www.redfin.com/city/30749/NY/New-York"
        }
    ],
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("cirkit/redfin-property-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 = {
    "searchUrls": [{ "url": "https://www.redfin.com/city/30749/NY/New-York" }],
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("cirkit/redfin-property-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "searchUrls": [
    {
      "url": "https://www.redfin.com/city/30749/NY/New-York"
    }
  ],
  "maxItems": 50
}' |
apify call cirkit/redfin-property-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,cirkit/redfin-property-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/4ARfaCR3h8fcCLeKx/builds/FaQvY7V3ZxRLTKpL0/openapi.json
