# Redfin Scraper: Property Listings, Sold Listings & Rentals (`hyperbach/redfin-scraper`) Actor

Scrape Redfin property listings: homes for sale, sold and for rent by search URL with its filters, city, ZIP code, neighborhood, county or home URL. Property data: id, URL, price, beds, baths, sq ft, lot size, year built, HOA fee, status, days on market, coordinates, MLS id, photos. No login.

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

## Pricing

from $0.25 / 1,000 homes

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Redfin Scraper: Property Listings, Sold Listings & Rentals

**Redfin homes, logged out: Redfin search URLs of a city, ZIP code, neighborhood or county with every filter you set on the site, place names or ZIP codes with a listing type (for sale, for rent, sold in the last month to 5 years), or home URLs in, one row per home out — the property id and URL, the listing type and status, the home type, price, price per square foot, HOA fee, beds, baths, square feet, lot size, year built, the address and coordinates, days on market, the sold date and price, the MLS id, the remarks and every photo URL; a rental's rent, bed, bath and size ranges with its building and units — several searches in one run, a max per search.** One free `search` row per input carries a completeness verdict: COMPLETE (the search's end), CAPPED (your limit), TRUNCATED (the site's own limit, with its reason) or PARTIAL. No login, no API key, no browser, proxies handled for you.

**$0.50 per 1,000 `home` rows on the Free plan, $0.425 on Starter.** A run start is $0.0035. The default input returns about 50 rows for about $0.0285. A value that names nothing is a free row that says why.

![A Redfin home page in a browser: a house photo with the price, beds, baths, size and address. Beside it, the row this Actor returns for the home, with photos as a list of full-size image URLs and photo_count, plus status, price, beds, baths, living area, address and days on market.](https://api.apify.com/v2/key-value-stores/dcLLNGq99686o2A4v/records/hero-redfin-scraper.webp)

### Why this Redfin scraper

- **Any Redfin search, as you set it.** Paste a search URL from your browser: a city, ZIP code, neighborhood or county, or a map area, with every filter you set on the site (price, beds, baths, home type, square feet, year built, sold within a period, rentals). Redfin's own search reads the filters, so the rows are what the site shows for that search.
- **Or just a place.** A city with its state (`Austin, TX`), a ZIP code, a neighborhood or a county, one a line, resolved by Redfin's own place search, for sale, for rent or sold in the last month to 5 years.
- **Sale, sold and rentals in one shape.** Every row has the same columns: a sold home carries its sale date and price, a home for sale its days on market and last sale date, a rental its rent, bed, bath and size ranges with the building's name and its available units. Column names follow our Zillow scraper's, so the two datasets join.
- **Every photo.** The full-size URL of every photo of the listing, and the count.
- **Whole searches, fast.** Redfin's own search gives up to 10,000 homes of a search in one request (measured 2026-10-31: 5,778 Austin homes for sale in 10.7 s); rentals come 350 a request with the site's count. A search past 10,000 homes says TRUNCATED: split it by price or area in the URL.
- **Honest runs.** A place Redfin does not know, a region that is not there and an empty search are checked twice before a free row says so; a home another search already delivered is delivered and charged once. Every input gets a row.

### Who it's for

- **Real estate investors and agents** — every home for sale in a city or ZIP code with its price per square foot, days on market and HOA fee, read again every day to see what is new and what moved.
- **Appraisers and market analysts** — sold comparables of a neighborhood or a county over a month to 5 years, with sale dates and prices, square feet, lot size and year built.
- **Rental market research** — the rentals of a city or ZIP code with their rent ranges, unit sizes and buildings.

### Quick start

**The first 100 homes for sale in a city**

```json
{
  "locations": [
    "Austin, TX"
  ],
  "listingType": "for_sale",
  "maxItemsPerSearch": 100
}
```

**A filtered search URL and the sold homes of a ZIP code**

```json
{
  "searchUrls": [
    "https://www.redfin.com/city/30818/TX/Austin/filter/property-type=house,max-price=500k,min-beds=3",
    "https://www.redfin.com/zipcode/78731/filter/include=sold-1yr"
  ],
  "maxItemsPerSearch": 200
}
```

**Rentals of a county and a home by URL**

```json
{
  "searchUrls": [
    "https://www.redfin.com/county/2866/TX/Travis-County/apartments-for-rent",
    "https://www.redfin.com/TX/Austin/3808-Balcones-Dr-78731/home/34166255"
  ],
  "maxItemsPerSearch": 300
}
```

### Output

One row per home (and one free search row per input):

| field | meaning |
|---|---|
| `row_type` | `home` (one home, charged) or `search` (the input's row with the walk's verdict; free). |
| `input_index` | The 1-based position of the input this row answers: `searchUrls` first, then `locations`. |
| `input_value` | The input as you gave it (the URL or the place). |
| `input_kind` | Which input it came from: `url` (`searchUrls`) or `location` (`locations`). |
| `search_url` | The Redfin search the input was read as (a place resolved to its region with the listing type), or the home's URL. |
| `status` | A search row: `ok`, `no_results`, `not_found`, `invalid`, `duplicate`, `failed` or `not_read` (see the FAQ). A home row: `ok`. |
| `status_detail` | Why a search row is not `ok`, in a sentence. |
| `scraped_at` | When the row was read (UTC). |
| `position` | The home's place among this input's delivered homes, in Redfin's own order (1 = first). |
| `property_id` | Redfin's property id (the number at the end of the home's URL): one row per property id a run. |
| `listing_id` | Redfin's listing id of this sale, or the rental's id. |
| `url` | The home's page on Redfin. |
| `listing_type` | `for_sale`, `sold` or `for_rent`. |
| `status_text` | The listing's status as Redfin shows it (`Active`, `Coming Soon`, `Pending`, `Closed`, `For rent` …). |
| `home_type` | `single_family`, `condo`, `townhouse`, `multi_family`, `manufactured`, `land`, `apartment` or `other`. |
| `price` | The list price, the sold price of a sold home, or a rental's lowest rent a month, in USD. |
| `price_max` | A rental's highest rent a month, in USD (its units' range). |
| `currency` | `USD`. |
| `price_per_sqft` | The price per square foot, in USD. |
| `hoa_fee` | The HOA fee a month, in USD, where the listing has one. |
| `beds` | Bedrooms (a rental: the fewest of its units). |
| `beds_max` | A rental: the most bedrooms of its units. |
| `baths` | Bathrooms, half baths as .5 (a rental: the fewest of its units). |
| `baths_max` | A rental: the most bathrooms of its units. |
| `full_baths` | Full bathrooms. |
| `partial_baths` | Partial bathrooms. |
| `living_area` | The living area in square feet (a rental: its smallest unit). |
| `living_area_max` | A rental: its largest unit in square feet. |
| `lot_area` | The lot size in square feet. |
| `year_built` | The year the home was built. |
| `stories` | Stories. |
| `address` | The full address: street, unit, city, state and ZIP code. |
| `street` | The street line. |
| `unit` | The unit number. |
| `city` | The city. |
| `state` | The state (two letters). |
| `zipcode` | The ZIP code. |
| `neighborhood` | The neighborhood or subdivision name the listing gives. |
| `latitude` | The latitude. |
| `longitude` | The longitude. |
| `days_on_market` | Days on market (for sale). |
| `sold_date` | A sold home: the sale date (`YYYY-MM-DD`). |
| `sold_price` | A sold home: the sale price in USD. |
| `last_sold_date` | A home for sale: the date of its last sale, where Redfin has one. |
| `mls_id` | The listing's MLS number. |
| `description` | The listing's remarks as Redfin's search gives them (often cut short by the site), or a rental's description. |
| `image_url` | The first photo's URL. |
| `photos` | Every photo's URL, full size. |
| `photo_count` | How many photo URLs `photos` holds. |
| `has_3d_tour` | The listing has a 3D tour. |
| `has_video` | The listing has a video tour. |
| `is_new_construction` | The home is new construction. |
| `tags` | Redfin's tags for the listing (`RESORT STYLE POOL`, `GUEST HOUSES` …). |
| `building_name` | A rental: the building's or community's name. |
| `units_available` | A rental: the units available in it. |
| `rent_updated_at` | A rental: when Redfin last updated it (UTC). |
| `place_resolved` | A search row: the place Redfin resolved the input to. |
| `region_id` | A search row: Redfin's region id of the search. |
| `region_type` | A search row: Redfin's region type (1 neighborhood, 2 ZIP code, 5 county, 6 city). |
| `filters` | A search row: the search's filters as Redfin writes them in a URL. |
| `homes_count` | A search row: Redfin's own count of the search's homes (rentals). |
| `homes_delivered` | A search row: the homes delivered for this input in this run. |
| `repeats_skipped` | A search row: homes met twice, or delivered by another input, and skipped. |
| `calls` | A search row: the calls to Redfin's search this input took. |
| `verdict` | A search row: COMPLETE, CAPPED, TRUNCATED or PARTIAL. |
| `verdict_detail` | A search row: the verdict in a sentence, with the counts. |

Example record:

```json
{
  "row_type": "home",
  "input_index": 5,
  "input_value": "https://www.redfin.com/TX/Austin/3808-Balcones-Dr-78731/home/34166255",
  "input_kind": "url",
  "search_url": "https://www.redfin.com/TX/Austin/3808-Balcones-Dr-78731/home/34166255",
  "status": "ok",
  "status_detail": null,
  "scraped_at": "2026-10-31T01:20:14Z",
  "position": 1,
  "property_id": "34166255",
  "listing_id": "224954003",
  "url": "https://www.redfin.com/TX/Austin/3808-Balcones-Dr-78731/home/34166255",
  "listing_type": "for_sale",
  "status_text": "Active",
  "home_type": "single_family",
  "price": 22000000,
  "price_max": null,
  "currency": "USD",
  "price_per_sqft": 1467,
  "hoa_fee": null,
  "beds": 5,
  "beds_max": null,
  "baths": 9.5,
  "baths_max": null,
  "full_baths": 8,
  "partial_baths": 3,
  "living_area": 15000,
  "living_area_max": null,
  "lot_area": 51836,
  "year_built": 2027,
  "stories": 3.0,
  "address": "3808 Balcones Dr, Austin, TX 78731",
  "street": "3808 Balcones Dr",
  "unit": null,
  "city": "Austin",
  "state": "TX",
  "zipcode": "78731",
  "neighborhood": "Colorado Foothills Sec 02",
  "latitude": 30.3176005,
  "longitude": -97.7665438,
  "days_on_market": 1,
  "sold_date": null,
  "sold_price": null,
  "last_sold_date": "2009-06-22",
  "mls_id": "1191266",
  "description": "Set behind private gates on prestigious Balcones Drive, The Gatsby is the ultimate trophy estate, where exceptional scale, craftsmanship, and timeless design converge. Spanning app …(truncated for display)",
  "image_url": "https://ssl.cdn-redfin.com/photo/92/bigphoto/266/1191266_0.jpg",
  "photos": [
    "https://ssl.cdn-redfin.com/photo/92/bigphoto/266/1191266_0.jpg",
    "https://ssl.cdn-redfin.com/photo/92/bigphoto/266/1191266_1_0.jpg",
    "https://ssl.cdn-redfin.com/photo/92/bigphoto/266/1191266_2_0.jpg",
    "https://ssl.cdn-redfin.com/photo/92/bigphoto/266/1191266_3_0.jpg",
    "https://ssl.cdn-redfin.com/photo/92/bigphoto/266/1191266_4_0.jpg",
    "https://ssl.cdn-redfin.com/photo/92/bigphoto/266/1191266_5_0.jpg",
    "https://ssl.cdn-redfin.com/photo/92/bigphoto/266/1191266_6_0.jpg",
    "https://ssl.cdn-redfin.com/photo/92/bigphoto/266/1191266_7_0.jpg",
    "https://ssl.cdn-redfin.com/photo/92/bigphoto/266/1191266_8_0.jpg",
    "https://ssl.cdn-redfin.com/photo/92/bigphoto/266/1191266_9_0.jpg",
    "https://ssl.cdn-redfin.com/photo/92/bigphoto/266/1191266_10_0.jpg",
    "https://ssl.cdn-redfin.com/photo/92/bigphoto/266/1191266_11_0.jpg",
    "https://ssl.cdn-redfin.com/photo/92/bigphoto/266/1191266_12_0.jpg",
    "https://ssl.cdn-redfin.com/photo/92/bigphoto/266/1191266_13_0.jpg",
    "https://ssl.cdn-redfin.com/photo/92/bigphoto/266/1191266_14_0.jpg",
    "https://ssl.cdn-redfin.com/photo/92/bigphoto/266/1191266_15_0.jpg",
    "https://ssl.cdn-redfin.com/photo/92/bigphoto/266/1191266_16_0.jpg",
    "https://ssl.cdn-redfin.com/photo/92/bigphoto/266/1191266_17_0.jpg",
    "https://ssl.cdn-redfin.com/photo/92/bigphoto/266/1191266_18_0.jpg",
    "https://ssl.cdn-redfin.com/photo/92/bigphoto/266/1191266_19_0.jpg",
    "https://ssl.cdn-redfin.com/photo/92/bigphoto/266/1191266_20_0.jpg",
    "https://ssl.cdn-redfin.com/photo/92/bigphoto/266/1191266_21_0.jpg"
  ],
  "photo_count": 22,
  "has_3d_tour": false,
  "has_video": false,
  "is_new_construction": true,
  "tags": [
    "PRIVATE WELLNESS CENTER",
    "CUSTOM WHISKEY ROOM",
    "SHOWPIECE KITCHEN",
    "DEDICATED PLAYROOM",
    "RESORT STYLE POOL",
    "GUEST HOUSES"
  ],
  "building_name": null,
  "units_available": null,
  "rent_updated_at": null,
  "place_resolved": null,
  "region_id": null,
  "region_type": null,
  "filters": null,
  "homes_count": null,
  "homes_delivered": null,
  "repeats_skipped": null,
  "calls": null,
  "verdict": null,
  "verdict_detail": null
}
```

### Pricing

**Pay for the homes a run delivers**, plus one run start; no platform usage is billed to you. The home price falls with your Apify plan.

| event | unit | Free | Starter | Scale | Business |
|---|---|---|---|---|---|
| Home (`home`) | per 1,000 | $0.50 | $0.425 | $0.35 | $0.25 |
| Run start (`start`) | per run | $0.0035 | $0.0035 | $0.0035 | $0.0035 |

A home is **$0.50 per 1,000** on the Free plan ($0.0005 a home), with every photo URL included. Each run that delivers a charged home also pays the **run start, $0.0035 once**; a run that delivers no charged home pays nothing at all. So one search of 100 homes costs $0.054 on the Free plan, and several searches in one run share one start. The free `search` row of every input, a value that is not a Redfin search or home URL (`invalid`), a place, region or home Redfin does not have (`not_found`), a search with no home (`no_results`), a repeated input (`duplicate`), an input left at a cap, the charge limit or the time limit (`not_read`) and a refusal the run could not pass (`failed`) are never charged. A home is charged once a run, also when several searches list it. A run that stops early (a timeout, an abort) is charged for the homes it delivered. Before the first request the log names the price of each row at your plan and the most the run can cost. Enterprise plans have their own rates: the Actor's Pricing tab shows the price for your plan.

### Usage patterns

- **URLs and places** — `searchUrls` takes Redfin search URLs as your browser shows them (`/city/<id>/<state>/<name>`, `/zipcode/<ZIP>`, `/neighborhood/<id>/<state>/<city>/<name>`, `/county/<id>/<state>/<name>`, each with its `/filter/…` part, `/rentals` or `/apartments-for-rent`), and home URLs (`/<state>/<city>/<address>-<ZIP>/home/<id>`). `locations` takes place names and ZIP codes, searched for `listingType`. A URL keeps its own listing type.
- **What a row is** — `row_type` = `home`: one home, in Redfin's own order (`position`). `row_type` = `search`: the free row of one input value — the `place_resolved`, the `region_id`, the `filters`, `homes_count` (the site's count, rentals), `homes_delivered`, `repeats_skipped`, `calls`, the `verdict` with its `verdict_detail`, and the `status` with its reason.
- **How far a search goes** — `maxItemsPerSearch` (default 1,000; 0 = all) stops each search after that many new homes, and `maxItems` stops the run. Redfin's search gives one search at most 10,000 homes for sale or sold (measured 2026-10-31: Los Angeles asked 20,000, gave 10,000); a run that reaches it says TRUNCATED, and a price band, a ZIP code or a neighborhood in the URL reads the others. Rentals page to the site's own count.
- **Home URLs** — A home URL is found in its ZIP code's lists on Redfin's search: for sale, sold in the last 5 years, then for rent. The row is the same row a search gives. A home URL takes 5-15 s (a ZIP code's sold list holds up to several thousand homes; measured 2026-10-31: four homes in four ZIP codes in 57 s), and the homes of one ZIP code share its lists in a run. A home in none of them (off the market for longer) gets a free `not_found` row: its own page sits behind a browser check this actor does not run.

### Input configuration

| field | type | default | what it does |
|---|---|---|---|
| `searchUrls` | `array` |  | Redfin search URLs as your browser shows them, one a line: a city, ZIP code, neighborhood or county search (`https://www.redfin.com/city/30818/TX/Austin`), with every filter you set on the site kept (`/filter/property-type=house,max-price=500k,min-beds=3`, a map area `viewport=…`, sold homes `include=sold-3mo`, rentals `/apartments-for-rent` or `/rentals`). A home URL (`https://www.redfin.com/TX/Austin/3808-Balcones-Dr-78731/home/34166255`) is found in its ZIP code's for-sale, sold (5 years) and rental lists. |
| `locations` | `array` |  | Places to search, one a line: a city with its state (`Austin, TX`), a ZIP code (`78731`), a neighborhood (`Hyde Park, Austin`) or a county (`Travis County, TX`). Each is resolved by Redfin's own place search (its first place) and searched for the listing type below. A place Redfin does not know gives a free row with no home. |
| `listingType` | `for_sale` / `for_rent` / `sold_1mo` / `sold_3mo` / `sold_6mo` / `sold_1yr` / `sold_3yr` / `sold_5yr` | `"for_sale"` | What the places above search: homes for sale, homes for rent, or homes sold in the last month to 5 years. A Redfin URL keeps its own (sold or rentals in the URL). |
| `maxItemsPerSearch` | `integer` | `1000` | Stop each search after this many new homes. 0 = every home Redfin gives the search: up to 10,000 for sale or sold (the site's limit of one search), every rental. |
| `maxItems` | `integer` | `0` | Stop the whole run after this many home rows, over every search. 0 = no run cap (each search keeps its own cap). |
| `feedback` | `string` |  | A note to the people who maintain this Actor: what you needed and did not get. For example a missing field, a wrong or empty result, or the Actor you switch from or to, and why. The run does not read it: the rows and the charges stay the same. A person reads every note. |

### Errors

**A run does not fail because of your input.** When an input cannot be used — a date that is not a date, an id in the wrong form, two settings that contradict each other — the run ends **Succeeded**, charges nothing, and says what to change:

- the status message starts with `INPUT REJECTED`;
- the dataset holds one row, `{"error": true, "code": "…", "message": "…"}`, and no results;
- the key-value store record `ERROR` holds the same object.

From code, check `error` on the first row before reading results.

A URL that is not a Redfin search or home URL (a market report, an apartment building's page, another site) is not an error: it gets one free `search` row with `status` invalid that says why, and the run goes on with the others. A run that ends **Failed** is a fault on our side, never your input; it charges nothing, and we are alerted.

### FAQ

**Which status is which?**

A search row's `status` is `ok` (homes served), `no_results` (Redfin lists nothing for it; read on two connections), `not_found` (a place, region or home Redfin does not have; checked on two connections), `invalid` (an empty value or a URL that is not a Redfin search or home URL), `duplicate` (the same search or home again in the input: read once; or a home another input already delivered), `failed` (the site refused every try; free) or `not_read` (left at a cap, the charge limit or the run's time limit). A home row's `status` is `ok`.

**Does it give the listing agent, the broker or the Redfin Estimate?**

No. Those are on each home's own page, which sits behind a browser check; this actor reads Redfin's search, where every field of the row is, up to 10,000 homes a request. The listing agent is a person, and no agent's name is delivered.

**Does it give a rental's phone number?**

No. A rental's leasing number can be a private landlord's, and it is not delivered.

**Does it need a Redfin account or API key?**

No. Everything is read from Redfin's public search, logged out.

### Integration

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('hyperbach/redfin-scraper').call({"locations": ["Austin, TX"], "listingType": "for_sale", "maxItemsPerSearch": 100});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

#### Python

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_TOKEN')
run = client.actor('hyperbach/redfin-scraper').call(run_input={'locations': ['Austin, TX'], 'listingType': 'for_sale', 'maxItemsPerSearch': 100})
items = client.dataset(run['defaultDatasetId']).list_items().items
```

#### CLI

```bash
apify call hyperbach/redfin-scraper --input '{"locations": ["Austin, TX"], "listingType": "for_sale", "maxItemsPerSearch": 100}'
```

#### REST

```bash
curl -X POST "https://api.apify.com/v2/acts/hyperbach~redfin-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H 'Content-Type: application/json' -d '{"locations": ["Austin, TX"], "listingType": "for_sale", "maxItemsPerSearch": 100}'
```

#### AI agents and MCP

Apify's MCP server offers this Actor as a tool to Claude, Cursor, VS Code and any other MCP client. Connect `https://mcp.apify.com?tools=hyperbach/redfin-scraper` and ask, for example: "Get 50 homes for sale in Austin, Texas from Redfin with the price, beds, baths, square feet and days on market". The agent fills the input from the table above and reads the rows from the run's dataset. The input names are the ones in the table above. An agent or a person can add `feedback` to any run and say what was needed and not delivered: a missing field, a wrong or empty result, the Actor switched from or to, and why. The run returns the same rows at the same price, and a person reads every note.

#### n8n, Make and Zapier

The Apify node in n8n, the Apify app in Make and the Apify integration in Zapier run this Actor on a schedule or from a trigger and read its dataset. A webhook on the run's end (Integrations on the Actor page) sends the rows on to your own endpoint. Nothing to install on our side.

### Support

**Disagree with a charge?** Write to apify@hyperbach.com with the run ID. We will ask Apify to compensate you, and the charge comes back to your Apify account as platform credit.

**Did it do the job?** A short [review on the Store](https://apify.com/hyperbach/redfin-scraper/reviews), at any rating, helps the next buyer choose.

### See also

- **[Zillow Scraper](https://apify.com/hyperbach/zillow-scraper)** — Zillow listings for sale, for rent and sold, by ZIP, city or search URL, with the Zestimate, and a property's price history.
- **[Immobiliare.it Scraper](https://apify.com/hyperbach/immobiliare-scraper)** — Immobiliare.it homes for sale and for rent by search URL or place name, with the price, surface, rooms, the address and coordinates, and the agency.
- **[Fotocasa Scraper](https://apify.com/hyperbach/fotocasa-scraper)** — Fotocasa.es homes for sale and for rent in Spain by place name or search URL, with the price, surface, rooms, the coordinates and the agency.
- **[StreetEasy Scraper](https://apify.com/hyperbach/streeteasy-scraper)** — StreetEasy NYC rentals and sales by search link, listing link or neighborhood, with the price, net effective rent, beds, baths, square feet, days on market, the building and the agents.
- **[Rightmove Scraper](https://apify.com/hyperbach/rightmove-scraper)** — Rightmove UK homes to buy or to rent by search link, listing link or place name, with the price, beds, baths, type, tenure, size, key features, floorplans and the agent branch.

*This page is generated from the Actor's schemas and a live sample — it cannot describe a field the Actor does not have.*

# Actor input Schema

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

Redfin search URLs as your browser shows them, one a line: a city, ZIP code, neighborhood or county search (`https://www.redfin.com/city/30818/TX/Austin`), with every filter you set on the site kept (`/filter/property-type=house,max-price=500k,min-beds=3`, a map area `viewport=…`, sold homes `include=sold-3mo`, rentals `/apartments-for-rent` or `/rentals`). A home URL (`https://www.redfin.com/TX/Austin/3808-Balcones-Dr-78731/home/34166255`) is found in its ZIP code's for-sale, sold (5 years) and rental lists.

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

Places to search, one a line: a city with its state (`Austin, TX`), a ZIP code (`78731`), a neighborhood (`Hyde Park, Austin`) or a county (`Travis County, TX`). Each is resolved by Redfin's own place search (its first place) and searched for the listing type below. A place Redfin does not know gives a free row with no home.

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

What the places above search: homes for sale, homes for rent, or homes sold in the last month to 5 years. A Redfin URL keeps its own (sold or rentals in the URL).

## `maxItemsPerSearch` (type: `integer`):

Stop each search after this many new homes. 0 = every home Redfin gives the search: up to 10,000 for sale or sold (the site's limit of one search), every rental.

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

Stop the whole run after this many home rows, over every search. 0 = no run cap (each search keeps its own cap).

## `feedback` (type: `string`):

A note to the people who maintain this Actor: what you needed and did not get. For example a missing field, a wrong or empty result, or the Actor you switch from or to, and why. The run does not read it: the rows and the charges stay the same. A person reads every note.

## Actor input object example

```json
{
  "searchUrls": [
    "https://www.redfin.com/city/30818/TX/Austin"
  ],
  "listingType": "for_sale",
  "maxItemsPerSearch": 50,
  "maxItems": 0
}
```

# Actor output Schema

## `results` (type: `string`):

All scraped records in the default dataset. One row per home (and one free search row per input):

## `runSummary` (type: `string`):

How the run went: home rows charged, free rows, inputs by status, the walk per search (homes delivered, calls, repeated homes skipped, the site's count, the verdict), the source counters (calls, served, refused, exits, rotations, bytes) and the memory watch.

# 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": [
        "https://www.redfin.com/city/30818/TX/Austin"
    ],
    "maxItemsPerSearch": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("hyperbach/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 = {
    "searchUrls": ["https://www.redfin.com/city/30818/TX/Austin"],
    "maxItemsPerSearch": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("hyperbach/redfin-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": [
    "https://www.redfin.com/city/30818/TX/Austin"
  ],
  "maxItemsPerSearch": 50
}' |
apify call hyperbach/redfin-scraper --silent --output-dataset

```

## MCP server setup

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