# Redfin Scraper - US Real Estate Listings & Sold Homes Data (`haketa/redfin-scraper`) Actor

Scrape Redfin.com property listings: price, beds, baths, sqft, $/sqft, HOA, year, status, sold data & more. Search by city/ZIP/county URL. Export to JSON, CSV, Excel.

- **URL**: https://apify.com/haketa/redfin-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Real estate, Lead generation, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 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/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 – Extract US Real Estate Listings & Property Data from Redfin.com

**Redfin Scraper** is a fast, no-code **Redfin.com data extractor** that turns one of the largest US real estate marketplaces into clean, structured, ready-to-use data. With this **Redfin scraper** you can **scrape Redfin listings** by city, ZIP code, neighborhood or county and pull **price, beds, baths, square footage, price per sqft, HOA, year built, listing status, MLS number, days on market, GPS coordinates, photos and full descriptions** — exported to JSON, CSV, Excel, HTML or XML in seconds.

No login. No Redfin API key. No coding. Just paste a Redfin search URL, press **Start**, and download a spreadsheet of US property listings.

> ⚡ **TL;DR** – Paste a Redfin.com search URL (city, ZIP, neighborhood or county) → choose property types and a limit → **Start** → download your real estate dataset. That's it.

---

### 🔑 Why use this Redfin Scraper?

Redfin is a leading US **real estate listings** platform with rich, MLS-backed property data that investors, agents and analysts rely on every day. The problem: Redfin offers **no public API** for bulk data, and copy-pasting listings by hand simply doesn't scale. This **Redfin data scraper** bridges that gap.

- ✅ **No login & no API key** – start scraping Redfin instantly, right out of the box.
- ✅ **Search by any Redfin URL** – city, ZIP code, neighborhood, or county pages all work.
- ✅ **Complete property data** – price, $/sqft, beds, baths, sqft, lot size, HOA, year built, status, MLS#, days on market, latitude/longitude, photos and listing description.
- ✅ **Property type filtering** – houses, condos, townhouses, multi-family, land and more.
- ✅ **Fast & low-cost** – powered by Redfin's own JSON data layer, not a slow headless browser.
- ✅ **Bulk export** – JSON, CSV, Excel (XLSX), HTML and XML, or pull straight from the Apify API.
- ✅ **Automation-ready** – schedule daily/weekly runs and connect to Google Sheets, Slack, Zapier, Make, webhooks, or use it as an AI agent tool.
- ✅ **Clean, structured output** – every listing is one tidy row, ready for Excel, BI tools, CRMs and data pipelines.

**Keywords this tool covers:** Redfin scraper, Redfin.com scraper, scrape Redfin, Redfin data extraction, US real estate scraper, real estate listings API alternative, MLS data, property data scraper, comps tool, CMA data, housing market analytics, real estate lead generation.

---

### 👤 Who is this Redfin Scraper for?

This tool is built around real jobs people need done. Find yourself below:

#### 🏦 Real estate investors & house flippers
Source deals faster. Pull every listing in a target city or ZIP, sort by **price per square foot**, filter by property type, and instantly spot underpriced homes. Track **days on market** to find motivated sellers and aging inventory. Build a repeatable deal-sourcing pipeline instead of refreshing Redfin by hand.

#### 🧑‍💼 Real estate agents, brokers & appraisers
Run a **comparative market analysis (CMA)** in minutes. Export comparable listings — price, $/sqft, beds, baths, sqft, year built, last sold date — for any neighborhood and hand your clients data-backed pricing. Monitor competitor inventory and new listings in your farm area automatically.

#### 🏗️ Proptech, real estate startups & portals
Power your product with a continuously refreshed **Redfin listings feed**. Each record ships with **GPS coordinates**, photos and descriptions, ready to plug into maps, valuation models, search portals, and CRMs.

#### 📊 Data analysts & researchers
Build structured **US housing datasets** for market research. Track asking prices, inventory, and **price/sqft** across cities, ZIP codes and counties over time. Perfect for affordability studies, trend dashboards and academic work.

#### 🏛️ Mortgage, insurance & relocation companies
Enrich your workflows with up-to-date property attributes (size, year built, HOA, type, location) for the US markets you serve — for underwriting, valuation, or relocation packages.

#### 📣 Real estate marketers & lead generation teams
Build targeted lists by location and property type to fuel ABM, direct mail and outreach campaigns aimed at specific neighborhoods and price bands.

---

### 📦 What data does the Redfin Scraper extract?

Every listing is saved as a clean, flat record with the following fields:

| Field | Type | Example | Description |
|---|---|---|---|
| `url` | string | `https://www.redfin.com/TX/Austin/.../home/123` | Direct link to the Redfin listing |
| `mlsId` | string | `1234567` | MLS number |
| `status` | string | `Active`, `Coming Soon` | Current listing status |
| `price` | number | `950000` | List price in USD |
| `pricePerSqFt` | number | `544` | Price per square foot |
| `beds` | number | `3` | Number of bedrooms |
| `baths` | number | `2.5` | Number of bathrooms |
| `sqFt` | number | `1745` | Interior square footage |
| `lotSize` | number | `8400` | Lot size in square feet |
| `yearBuilt` | number | `1954` | Year the home was built |
| `propertyType` | string | `House`, `Condo/Co-op` | House, Condo/Co-op, Townhouse, Multi-family, Land, Other |
| `hoaMonthly` | number | `250` | Monthly HOA fee in USD |
| `address` | string | `1701 Aggie Ln` | Street address |
| `unitNumber` | string | `Unit 5C` | Unit number (if applicable) |
| `city` | string | `Austin` | City |
| `state` | string | `TX` | State code |
| `zip` | string | `78757` | ZIP code |
| `latitude` | number | `30.3468` | Latitude (GPS) |
| `longitude` | number | `-97.7811` | Longitude (GPS) |
| `daysOnMarket` | number | `1` | Days the listing has been on market |
| `soldDate` | string (ISO) | `2006-06-23T...` | Last recorded sale date (price history — see notes) |
| `isNewConstruction` | boolean | `false` | New construction flag |
| `hasVirtualTour` | boolean | `true` | Virtual tour available |
| `has3DTour` | boolean | `false` | 3D tour available |
| `isHot` | boolean | `true` | Redfin "hot home" flag |
| `photoCount` | number | `25` | Number of photos |
| `photo` | string | photo URL | Main photo URL (when available) |
| `description` | string | listing remarks | Full listing description |
| `propertyId` | number | `12345678` | Redfin internal property ID |
| `listingId` | number | `215615566` | Redfin internal listing ID |
| `scrapedAt` | string (ISO) | `2026-05-22T...` | Extraction timestamp |

> Tip: after export, filter by `status`, sort by `pricePerSqFt`, or pivot on `zip`/`propertyType` to slice the data any way you need.

---

### 🚀 How to use the Redfin Scraper (step by step)

You don't need any technical skills:

1. **Search on Redfin.com** for a city, ZIP code, neighborhood or county — and apply any filters you like (price range, beds, etc.).
2. **Copy the URL** from your browser's address bar.
3. **Open the Actor** and paste the URL into the **Redfin search URLs** field. Add as many URLs as you want.
4. **(Optional) Pick property types** (houses, condos, townhouses, multi-family, land) and set a **Max items** limit to control cost.
5. Click **Start** ▶️ and let it run.
6. When finished, open the **Storage → Dataset** tab and **export** as JSON, CSV, Excel, HTML or XML — or grab the data via the Apify API.

That's all — you now have a structured Redfin dataset you can open in Excel, Google Sheets, or load into any tool.

---

### ⚙️ Input examples

#### Example 1 – All listings in a city
```json
{
  "startUrls": [
    { "url": "https://www.redfin.com/city/30749/NY/New-York" }
  ],
  "maxItems": 200
}
````

#### Example 2 – Condos in a specific ZIP code

```json
{
  "startUrls": [
    { "url": "https://www.redfin.com/zipcode/78731" }
  ],
  "propertyTypes": ["condo"],
  "maxItems": 100
}
```

#### Example 3 – Houses & townhouses across multiple areas

```json
{
  "startUrls": [
    { "url": "https://www.redfin.com/city/30818/TX/Austin" },
    { "url": "https://www.redfin.com/county/321/TX/Travis-County" }
  ],
  "propertyTypes": ["house", "townhouse"],
  "maxItems": 500
}
```

#### Example 4 – Full coverage of a metro via several ZIP codes

```json
{
  "startUrls": [
    { "url": "https://www.redfin.com/zipcode/90001" },
    { "url": "https://www.redfin.com/zipcode/90002" },
    { "url": "https://www.redfin.com/zipcode/90003" }
  ],
  "maxItems": 1000
}
```

***

### 📤 Output example

```json
{
  "url": "https://www.redfin.com/TX/Austin/1701-Aggie-Ln-78757/home/12345678",
  "mlsId": "1234567",
  "status": "Active",
  "price": 950000,
  "pricePerSqFt": 544,
  "beds": 3,
  "baths": 2,
  "sqFt": 1745,
  "lotSize": 8400,
  "yearBuilt": 1954,
  "propertyType": "House",
  "hoaMonthly": null,
  "address": "1701 Aggie Ln",
  "city": "Austin",
  "state": "TX",
  "zip": "78757",
  "latitude": 30.3468,
  "longitude": -97.7811,
  "daysOnMarket": 1,
  "soldDate": "2006-06-23T07:00:00.000Z",
  "isNewConstruction": false,
  "hasVirtualTour": false,
  "photoCount": 25,
  "description": "Charming mid-century home on a large lot...",
  "propertyId": 12345678,
  "listingId": 215615566,
  "scrapedAt": "2026-05-22T13:02:20.645Z"
}
```

***

### 📝 Input parameters reference

| Parameter | Type | Default | Description |
|---|---|---|---|
| `startUrls` | array of URLs | – | Redfin city / ZIP / neighborhood / county search URLs. |
| `propertyTypes` | array | all | Any of `house`, `condo`, `townhouse`, `multifamily`, `land`, `other`. |
| `maxItems` | integer | `0` (no limit) | Max listings to scrape across the run. Each search URL returns up to ~350. |
| `maxConcurrency` | integer | `5` | Max search URLs processed in parallel. |
| `maxRequestRetries` | integer | `3` | Retries per failed request. |
| `proxyConfiguration` | object | Apify Proxy (US) | Proxy settings; US-based proxies recommended for Redfin. |

***

### 🌍 How to find Redfin URLs

Redfin search URLs are easy to grab — just search on redfin.com and copy the address bar. The scraper detects the region automatically from any of these URL shapes (no IDs to look up by hand):

- **City**: `https://www.redfin.com/city/30818/TX/Austin`
- **ZIP code**: `https://www.redfin.com/zipcode/78731`
- **County**: `https://www.redfin.com/county/321/TX/Travis-County`
- **Neighborhood**: `https://www.redfin.com/neighborhood/...`

You can mix and match URL types in a single run, and you can apply Redfin's own filters before copying the URL.

#### Popular US markets to scrape

| Region type | Examples |
|---|---|
| Major metros (city) | New York, Los Angeles, Chicago, Houston, Phoenix, Austin, Seattle, Miami |
| High-growth ZIPs | Target specific ZIP codes for focused, full-coverage pulls |
| Counties | Travis County (TX), King County (WA), Maricopa County (AZ), Cook County (IL) |
| Neighborhoods | Drill into a single neighborhood for hyper-local comps |

Because each search is capped at ~350 homes (Redfin's limit), scraping a **list of ZIP codes** is the most reliable way to fully cover a large metro without missing listings.

***

### 🛠️ How it works (under the hood)

This scraper is built for speed and reliability:

1. It reads the **region** (region ID + type) straight from the Redfin search page — so any city/ZIP/county/neighborhood URL just works.
2. It calls Redfin's own **JSON data endpoint** (the same one that powers the map view) to pull structured listing data — no fragile HTML parsing, no heavy headless browser.
3. It **normalizes** each listing into a clean, flat record and applies your property-type filter.
4. Results stream into the Apify dataset, ready to export or pipe anywhere.

Because it uses a lightweight HTTP client instead of a browser, runs are **fast and cheap**, and it includes **automatic retries** for resilience.

***

### 📊 Understanding the data (important notes)

- **~350 homes per search:** Redfin caps map results at roughly 350 homes per area. To cover an entire metro, scrape several **ZIP codes** or neighborhoods rather than one big city URL.
- **`soldDate` = price history:** This is the property's **last recorded sale date**, not its current status. An active listing can still carry an old `soldDate` from a previous sale. Always use the `status` field for the current state (Active, Coming Soon, etc.).
- **Hidden / unavailable fields:** Redfin occasionally restricts a field on certain listings (e.g. exact sqft on some pre-market homes). Those are returned as `null` rather than a wrong value.
- **Property type filtering** is applied to the results, so requesting only `condo` returns only condos found in that area.
- **Empty fields are normal:** condos have no `lotSize`, non-HOA homes have no `hoaMonthly`, etc.

***

### 💡 Tips & best practices

- **Control cost with `maxItems`.** Start with 50–100 to preview, then scale up.
- **Scrape ZIP codes for full coverage** of a large metro (each city page is capped at ~350 homes).
- **Filter by property type** to keep datasets focused (e.g. only condos for a rental study).
- **Schedule the Actor** daily/weekly to maintain a fresh listings feed or price-tracking dataset.
- **Use coordinates** (`latitude`/`longitude`) to map listings or join with other geo datasets.
- **Track `price` + `daysOnMarket` over time** to spot price drops and stale inventory.
- **Keep US proxies on** — Redfin is a US site and serves best from US IPs (enabled by default).

***

### 🔄 Keeping your data fresh & automating

US listings change daily — homes list, go pending, and sell fast. To keep a live dataset:

1. **Schedule the Actor** to run daily or weekly from the Apify Console.
2. **De-duplicate** downstream by `propertyId` or `url` (each listing is unique).
3. Connect a **webhook**, **Google Sheets** or **Slack** integration for instant new-listing alerts.
4. **Compare snapshots** over time to detect price changes and measure how fast homes sell in each area.

This turns the scraper into a live feed for deal alerts, CMA dashboards, BI reports, or a property portal.

***

### 🔌 Integrations & automation

This Redfin Scraper plugs straight into your stack:

- **Apify API** – trigger runs and pull data programmatically.
- **Webhooks** – get notified when a run finishes.
- **Zapier, Make (Integromat), n8n** – push results into thousands of apps.
- **Google Sheets, Slack, Airtable, Excel** – send listings where your team works.
- **MCP / AI agents** – use this Actor as a tool for LLM-powered agents.
- **Scheduler** – run automatically on a daily, weekly or custom schedule.

***

### 👩‍💻 Using the Redfin Scraper via API

Call this Actor from any language using the [Apify API](https://docs.apify.com/api/v2).

**Python:**

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
    "startUrls": [{ "url": "https://www.redfin.com/city/30818/TX/Austin" }],
    "propertyTypes": ["house"],
    "maxItems": 200,
}

run = client.actor("YOUR_USERNAME/redfin-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["address"], "-", item.get("price"), "-", item.get("sqFt"), "sqft")
```

**JavaScript / Node.js:**

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });

const input = {
    startUrls: [{ url: 'https://www.redfin.com/zipcode/78731' }],
    maxItems: 100,
};
const run = await client.actor('YOUR_USERNAME/redfin-scraper').call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

***

### ⚖️ Redfin Scraper vs. the alternatives

| | Manual copy-paste | Redfin's site | **This Redfin Scraper** |
|---|---|---|---|
| Bulk export | ❌ One by one | ❌ No public API | ✅ Hundreds at once |
| Structured data | ❌ | ⚠️ Limited | ✅ Clean JSON/CSV/Excel |
| Property type filter | ⚠️ Manual | ✅ | ✅ |
| Automation / scheduling | ❌ | ❌ | ✅ |
| Coordinates & photos | ❌ | ⚠️ | ✅ |
| Cost | High (your time) | – | Low (pay per result) |

***

### ❓ Frequently asked questions

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

No. This scraper uses only publicly available data on redfin.com. No login, cookies or Redfin API key required.

#### How many listings can I scrape?

Each search URL returns up to ~350 homes (Redfin's per-area limit). To cover an entire metro, scrape several ZIP codes or neighborhoods. Use `maxItems` to cap the total across the run.

#### Can I filter by property type?

Yes — choose any combination of house, condo, townhouse, multi-family, land or other. The filter is applied to the results returned for each area.

#### What does `soldDate` mean?

It's the property's last recorded sale date (price history). It can appear on an active listing from a previous sale, so always use `status` for the current state.

#### Why are some fields empty (null)?

Redfin doesn't publish every field for every listing (e.g. lot size for condos, HOA for non-HOA homes), and occasionally restricts a field on pre-market listings. Missing values are returned as `null`.

#### In what formats can I download the data?

JSON, CSV, Microsoft Excel (XLSX), HTML table, and XML — plus direct API access and dataset views.

#### How fresh is the data?

The scraper fetches live data from Redfin.com on every run, so results reflect the site's current state. Schedule it to keep your dataset up to date.

#### Can I scrape sold homes?

This version focuses on active and coming-soon listings (the most reliable data). Each listing still includes its last `soldDate` (price history). Need full sold-history coverage? Open an issue and let us know.

***

### 🧰 Troubleshooting

- **"Could not resolve region"** – make sure the URL is a real Redfin search page (city/ZIP/neighborhood/county), not a single listing or an account page.
- **Fewer results than expected** – remember the ~350-per-area cap; split large cities into ZIP codes.
- **Getting blocked or empty results** – keep **US-based Apify Proxy** enabled and avoid setting concurrency too high.
- **A field is missing** – it may simply not be published for that listing (returned as `null`).

***

### ⚖️ Is it legal to scrape Redfin.com?

This Actor collects only **publicly available information** that anyone can view on redfin.com without logging in. Web scraping of public data is generally legal, but **how you use the data is your responsibility**:

- Do not use the data in ways that violate privacy laws (GDPR, CCPA, etc.).
- Do not republish copyrighted content (listing photos or descriptions) in infringing ways.
- Respect Redfin's Terms of Service and any applicable MLS data rules.
- Use the data for legitimate purposes such as research, analytics and aggregated market insight.

If you're unsure about your specific use case, consult a legal professional.

***

### 🛟 Support & feedback

Found a bug, missing a field, or need a new feature (like sold-history or extra filters)? Open an issue on the Actor's **Issues** tab — feedback is welcome and directly shapes the roadmap. If a listing or search URL fails, please include the exact URL so it can be reproduced quickly.

***

### 🏷️ Keywords

Redfin scraper, Redfin.com scraper, scrape Redfin, Redfin data extractor, Redfin API alternative, US real estate scraper, real estate listings scraper, property data extraction, MLS data scraper, real estate comps tool, CMA data, $/sqft data, housing market data, property price scraper, real estate lead generation, proptech data feed, scrape real estate by ZIP code, export Redfin to CSV Excel JSON, US property dataset.

***

*This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Redfin Corporation. "Redfin" is a trademark of its respective owner.*

# Actor input Schema

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

Paste Redfin.com search URLs — by city, ZIP code, neighborhood or county. Examples:<ul><li><code>https://www.redfin.com/city/30749/NY/New-York</code></li><li><code>https://www.redfin.com/zipcode/78731</code></li><li><code>https://www.redfin.com/county/321/TX/Travis-County</code></li></ul>Build any filtered search on redfin.com and paste the URL. Each search returns up to ~350 homes (Redfin's per-area limit).

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

Which property types to include. Leave all selected for everything.

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

Maximum number of listings to scrape across the whole run. Use this to control cost. Set 0 for no limit (up to ~350 per search URL).

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

Maximum number of search URLs processed in parallel.

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

How many times a failed request is retried before being marked as failed.

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

Proxy settings. Redfin works from most connections; US-based proxies are recommended. Apify Proxy is enabled by default.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.redfin.com/city/30749/NY/New-York"
    }
  ],
  "propertyTypes": [
    "house",
    "condo",
    "townhouse",
    "multifamily",
    "land",
    "other"
  ],
  "maxItems": 100,
  "maxConcurrency": 5,
  "maxRequestRetries": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `datasetItems` (type: `string`):

All extracted property listings for this run.

## `overviewTable` (type: `string`):

A clean, human-readable table view of the scraped listings.

# 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/30749/NY/New-York"
        }
    ],
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/redfin-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/30749/NY/New-York" }],
    "maxItems": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/redfin-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/30749/NY/New-York"
    }
  ],
  "maxItems": 100
}' |
apify call haketa/redfin-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Redfin Scraper - US Real Estate Listings & Sold Homes Data",
        "description": "Scrape Redfin.com property listings: price, beds, baths, sqft, $/sqft, HOA, year, status, sold data & more. Search by city/ZIP/county URL. Export to JSON, CSV, Excel.",
        "version": "1.0",
        "x-build-id": "QZDMNzEDdDSzsgRSy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/haketa~redfin-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-haketa-redfin-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/haketa~redfin-scraper/runs": {
            "post": {
                "operationId": "runs-sync-haketa-redfin-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/haketa~redfin-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-haketa-redfin-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",
                "properties": {
                    "startUrls": {
                        "title": "Redfin search URLs",
                        "type": "array",
                        "description": "Paste Redfin.com search URLs — by city, ZIP code, neighborhood or county. Examples:<ul><li><code>https://www.redfin.com/city/30749/NY/New-York</code></li><li><code>https://www.redfin.com/zipcode/78731</code></li><li><code>https://www.redfin.com/county/321/TX/Travis-County</code></li></ul>Build any filtered search on redfin.com and paste the URL. Each search returns up to ~350 homes (Redfin's per-area limit).",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "propertyTypes": {
                        "title": "Property types",
                        "type": "array",
                        "description": "Which property types to include. Leave all selected for everything.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "house",
                                "condo",
                                "townhouse",
                                "multifamily",
                                "land",
                                "other"
                            ],
                            "enumTitles": [
                                "House",
                                "Condo / Co-op",
                                "Townhouse",
                                "Multi-family",
                                "Land",
                                "Other / Mobile"
                            ]
                        },
                        "default": [
                            "house",
                            "condo",
                            "townhouse",
                            "multifamily",
                            "land",
                            "other"
                        ]
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of listings to scrape across the whole run. Use this to control cost. Set 0 for no limit (up to ~350 per search URL).",
                        "default": 0
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum number of search URLs processed in parallel.",
                        "default": 5
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 0,
                        "maximum": 15,
                        "type": "integer",
                        "description": "How many times a failed request is retried before being marked as failed.",
                        "default": 3
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Redfin works from most connections; US-based proxies are recommended. Apify Proxy is enabled by default.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyCountry": "US"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
