# Redfin API (`truefetch/redfin-api`) Actor

Search Redfin sale listings across the United States and Canada. Collect 40 normalized property fields covering prices, beds, baths, area, images, listing details, agent data, and source URLs.

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

## Pricing

from $11.70 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#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

> **Affiliate disclosure:** Apify links in this README may include referral parameters. If you sign up through one of them, TrueFetch may receive a commission at no extra cost to you.

Redfin Real Estate Listings turns one authorised United States or Canada for-sale search into a traceable dataset of normalised property advertisements.

- Search only active sale inventory; rental, sold, and posted-date modes are not exposed by this Actor.
- Use country-aware location routing for the United States or Canadian city-and-province paths.
- Collect up to 40 fields covering listing identity, price, rooms, area, address, images, attributes, contacts, source URLs, and processing metadata.
- Public Store proof is an old deployment snapshot: 4 total users, 2 monthly active users, 1 bookmark, and no published ratings observed on July 21, 2026; current behaviour is verified from the local repository instead.

[Run Redfin Real Estate Listings on Apify](https://console.apify.com/actors/VILUQtAHXdkcVPjN4/input?utm_source=truefetch\&utm_medium=readme\&utm_campaign=redfin-real-estate-listings) with one expressly permitted result before expanding the request.

### What does Redfin Real Estate Listings do?

Redfin Real Estate Listings is a source-specific Apify Actor for collecting for-sale property records from Redfin search flows in supported United States and Canadian locations. You provide a country, location, and maximum result count. An optional property category can narrow the search. The only public transaction value is `for_sale`, so the Actor does not promise rental or sold inventory.

The runtime resolves the requested place, creates either a United States Redfin search or a Canadian Redfin path, obtains candidate records, enriches available details, and pushes accepted items to the default dataset. The 40-field schema gives downstream code a consistent envelope even though listing publishers and MLS feeds expose different fields.

TrueFetch is not affiliated with or endorsed by Redfin. This Actor supplies automation software but no right to Redfin or MLS content. Redfin's current Terms of Use prohibit automated crawling or querying, including screen and database scraping, without prior express written permission from the applicable Redfin company. MLS notices can add personal-use, redistribution, accuracy, and attribution limits. Run the Actor only when all relevant rights holders permit your exact access and reuse.

### How do I run Redfin Real Estate Listings?

Begin with a location format the current country branch can resolve. For Canada, the runtime needs a city plus a recognised province or territory code. The shared scenario below requests one condo for sale in Toronto, Ontario. It is intentionally small enough for a human to examine every returned field and its provenance.

```json
{
  "country": "Canada",
  "location": "Toronto, ON",
  "max_results": 1,
  "listing_type": "for_sale",
  "property_type": "condo"
}
```

Start the run, wait for it to finish, inspect the default dataset, and compare any item with its `source_url` only under your permission. Confirm that the location stayed in the intended country and province, the category really narrowed the listing path, and the monetary currency and area unit are interpreted correctly.

`max_results` is a ceiling rather than a service-level promise. Fewer items can be saved when the search has limited matching stock, Redfin changes a page or response, a listing vanishes during the run, or a detail response lacks enough usable data. Scale only after the one-result run demonstrates legal authority, acceptable cost, correct geography, and sufficient field quality.

### What data does Redfin Real Estate Listings return?

Dataset items follow a 40-field public schema. This example illustrates the Toronto scenario and does not describe an actual current home:

```json
{
  "platform": "Redfin",
  "title": "Example condo for sale in Toronto",
  "listing_id": "example-listing-id",
  "mls_id": "example-mls-id",
  "listing_type": "for_sale",
  "property_type": "Condo",
  "price": {
    "value": 735000,
    "currency": "CAD"
  },
  "rooms": {
    "bedrooms": 2,
    "bathrooms": 2
  },
  "area": {
    "value": 890,
    "unit": "sqft"
  },
  "location": "Toronto, ON",
  "address": {
    "city": "Toronto",
    "state": "ON",
    "country": "Canada"
  },
  "cover_image": "https://example.com/property.jpg",
  "source_url": "https://www.redfin.ca/on/toronto/example",
  "processed_at": "2026-07-21T12:00:00Z"
}
```

Identity and source fields are `platform`, `title`, `description`, `listing_id`, `mls_id`, `source_url`, and `official_url`. Classification fields are `listing_type`, `availability`, `market_type`, `property_type`, `subtype`, `category`, and `business_type`. Pricing, dimensions, and timing use `price`, `rooms`, `area`, `land`, `building`, `dates`, `posted_time`, and `fees`. Location uses `location`, `address`, `geo`, `country`, and `nearby`. Media and characteristics use `cover_image`, `image_urls`, `media`, `open_houses`, `features`, `amenities`, and `details`. The remaining groups include `contact`, `reviews`, `policies`, `units`, `processor`, and `processed_at`.

These are possible keys, not guarantees of populated values. MLS providers can withhold fields, measurements can be estimates, and price or area representations can vary by country. Preserve the collection timestamp and source reference, validate nested values, and independently confirm any fact used for a material decision.

### What inputs can I configure?

| Input | Required | Accepted values and effect |
| --- | --- | --- |
| `country` | Yes | `Canada` or `United States`; selects the country-specific Redfin route. |
| `location` | Yes | Supported city, region, neighbourhood, postal code, or address. Canadian city searches require a recognised province/territory. |
| `max_results` | Yes | Integer from 1 through 10,000; actual output can be lower. |
| `listing_type` | No | `for_sale` only. |
| `property_type` | No | `residential`, `house`, `apartment`, `condo`, `townhouse`, or `land`. |

An empty property type uses Redfin's general residential sale path. In the current implementation, `apartment` and `condo` map to the same condo-style filter; `house`, `townhouse`, and `land` have their own mappings. `residential` means no narrower type filter. Leave the field blank when broad sale inventory is intended.

The Actor does not expose rent, sold, recency, price, bedroom, bathroom, radius, open-house, school, or keyword inputs. Even if the Redfin website offers more controls, undocumented keys are not supported Actor filters. Do not assume a field affected the source request simply because it was included in JSON.

### What platforms and markets does Redfin Real Estate Listings cover?

Coverage is one platform and two countries: Redfin in the United States and Redfin Canada. United States searches can resolve a five-digit ZIP code directly or use geographic bounds for a city or point. Canadian searches use Redfin.ca city paths tied to recognised province and territory abbreviations. These branches are not identical and can have different listing fields and route behaviour.

Only for-sale records are in scope. The Actor does not provide Redfin rental listings, sold-history feeds, market trend series, ownership data, valuations, tax records, mortgage quotes, off-market homes, or complete MLS access. Country inclusion does not mean every state, province, territory, city, or MLS has equal coverage.

### Why use Redfin Real Estate Listings?

When permission exists, this Actor offers a compact way to transform source-specific sale advertisements into a common review format. A researcher can inspect a one-neighbourhood sample, a data-quality team can compare internal records with authorised public references, and a portfolio team can track a limited search while retaining source URLs and collection time.

The Actor does not turn advertisement data into an appraisal or verified property record. Prices can be asking prices, measurements can be estimates, status can lag a transaction, and descriptions originate from listing participants. Use official registries, licensed MLS products, inspections, and qualified real-estate, legal, tax, or financial professionals for decisions that require authoritative evidence.

Because Redfin content can incorporate multiple MLS providers, permissions may be record-specific. Minimise volume and fields, preserve required attribution, avoid redistributing photos or remarks, and apply retention and access controls matched to the licence.

### Who is Redfin Real Estate Listings for?

It may fit teams with Redfin's express written permission and any required MLS rights: authorised brokerages, licensed data users, researchers, portfolio operators, compliance-conscious analysts, and developers testing an approved workflow. The Actor can be invoked manually or through Apify APIs, schedules, webhooks, clients, and MCP integrations.

It is not appropriate for anonymous bulk scraping, unrestricted commercial reuse, database building, republication, unsolicited lead generation, or use outside MLS terms. A business case does not create permission. If the applicable Redfin company and MLS rights cannot be identified, do not start a run.

### How can I use Redfin Real Estate Listings through the API or MCP?

The API slug is `truefetch~redfin-real-estate-listings`. Send the same five public inputs to the Apify Actor run endpoint and consume the default dataset after confirming a successful terminal status. For a one-item test, the synchronous dataset-items endpoint is convenient; for larger authorised jobs, an asynchronous run provides clearer monitoring and failure handling. See the [official Apify API page](https://apify.com/truefetch/redfin-real-estate-listings/api).

An MCP client can register the current Actor ID:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=actors&actors=VILUQtAHXdkcVPjN4"
    }
  }
}
```

Use the [Actor MCP setup page](https://apify.com/truefetch/redfin-real-estate-listings/api/mcp) for the current connection flow. Store tokens as secrets, restrict run permissions, cap costs, and require the invoking person or agent to use only approved inputs and purposes.

### How much does Redfin Real Estate Listings cost?

The Actor uses pay-per-event pricing. A start event costs **$0.01000**. Every result saved to the default dataset costs **$0.01300** on FREE, **$0.01257** on BRONZE, **$0.01213** on SILVER, and **$0.01170** on GOLD, PLATINUM, or DIAMOND. The one-result Toronto scenario therefore has a maximum Actor-event charge of **$0.02300 on FREE**, excluding separate Apify subscription or infrastructure usage.

The start charge can apply even when zero records are returned. Result events are based on items actually pushed, not `max_results`. Verify the live Pricing tab before production because event rates can change after the documentation date.

### How does Redfin Real Estate Listings compare with alternatives?

Use this Actor for an authorised, for-sale-only Redfin workflow spanning the United States or Canada. Zillow Real Estate Listings supports more transaction types in those countries. Realtor Real Estate Listings is United States-only but includes sale, rent, and sold modes. Global Real Estate Listings is suited to projects that need explicit platform selection and broader country routing.

A licensed MLS or broker feed may be more appropriate when completeness, redistribution rights, attribution, stable fields, or service commitments matter. Redfin's site can aggregate third-party MLS content with separate notices, so a direct agreement with the relevant provider may offer a clearer production basis. Choose the least intrusive source that fulfils the authorised need.

### What are the limits and troubleshooting steps?

Redfin can change routes, markup, geographic identifiers, internal responses, and access controls without notice. Detail requests may fail while search records remain available. Results can contain missing images, partial addresses, estimated measurements, or differing units. Repeated runs can differ as listings change. No completeness, accuracy, freshness, uptime, or minimum result count is guaranteed.

Permission is the first troubleshooting gate. Current terms at `https://www.redfin.com/about/terms-of-use` state that automated crawling or querying requires prior express written permission from the applicable Redfin company. Individual MLS notices can restrict information to personal, non-commercial property identification and bar reproduction or redistribution. The Actor does not override those rules.

For an authorised technical failure, retry the shared Toronto input; remove `property_type`; verify the country, city, and province; inspect logs and dataset count; and compare a returned source URL. A useful issue includes the run ID, sanitised input, UTC timestamp, expected result, actual result, and exact error. Never disclose tokens, credentials, or unnecessary personal information.

### Frequently asked questions

#### Can this Actor search rentals or sold homes?

No. The current public listing type is `for_sale` only.

#### Does Canada use the same location routing as the United States?

No. Canadian city searches depend on recognised province/territory paths, while US searches can use ZIP or geographic bounds.

#### Are apartment and condo separate Redfin filters?

Not in the current mapping. Both select the condo-style property filter.

#### Are all 40 fields guaranteed?

No. They form a normalised envelope; source and MLS availability determine populated values.

#### Does paying Apify grant Redfin or MLS rights?

No. Actor charges are separate from source licences and permissions.

### Related TrueFetch Actors

- [Global Real Estate Listings](https://apify.com/truefetch/global-real-estate-listings) — broader platform and country routing.
- [Zillow Real Estate Listings](https://apify.com/truefetch/zillow-real-estate-listings) — sale, rental, and sold searches in the United States and Canada.
- [Realtor Real Estate Listings](https://apify.com/truefetch/realtor-real-estate-listings) — United States Realtor.com listings.
- [Domain Real Estate Listings](https://apify.com/truefetch/domain-real-estate-listings) — Australian sale and rental listings.

Choose based on source authorisation, market, transaction mode, and required provenance.

### Support and last updated

Report reproducible defects through the [Actor Issues tab](https://apify.com/truefetch/redfin-real-estate-listings/issues) with a run ID and sanitised evidence. Do not place confidential permissions, API tokens, or personal data in a public issue.

Documentation last verified **July 21, 2026** against the current repository's Actor metadata, input schema, dataset and storage schemas, event pricing, and read-only Redfin runtime path. Opening Store figures remain explicitly labelled as an older deployed snapshot rather than proof of current local behaviour.

[Open Redfin Real Estate Listings and run the one-result check](https://console.apify.com/actors/VILUQtAHXdkcVPjN4/input?utm_source=truefetch\&utm_medium=readme\&utm_campaign=redfin-real-estate-listings-support).

# Actor input Schema

## `country` (type: `string`):

Country where Redfin listings will be searched

## `location` (type: `string`):

City, region, neighborhood, postal code, or address supported by Redfin

## `max_results` (type: `integer`):

Maximum number of Redfin property listings to return

## `listing_type` (type: `string`):

Choose the transaction status to search

## `property_type` (type: `string`):

Optional property or asset type filter. Leave empty to include all supported property types

## Actor input object example

```json
{
  "country": "United States",
  "location": "Seattle, WA",
  "max_results": 10
}
```

# Actor output Schema

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

Overview table for the default dataset of normalized property 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 = {
    "country": "United States",
    "location": "Seattle, WA",
    "max_results": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("truefetch/redfin-api").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 = {
    "country": "United States",
    "location": "Seattle, WA",
    "max_results": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("truefetch/redfin-api").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 '{
  "country": "United States",
  "location": "Seattle, WA",
  "max_results": 10
}' |
apify call truefetch/redfin-api --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/VILUQtAHXdkcVPjN4/builds/SOonyGSRHYxYqBg0K/openapi.json