How to Scrape Redfin for Property Data Extraction

Searching for a Redfin API is the natural starting point for anyone building a real estate data pipeline, and it leads to a dead end. Redfin does not offer a public API for developers. What it does have are internal JSON endpoints used by its own web application; those endpoints are technically reachable but undocumented, rate-limited, and prone to breaking when Redfin updates its frontend.

The practical path forward is web scraping, and this guide covers three approaches that work in 2026: tapping Redfin's internal JSON endpoints directly, writing a Python scraper using the requests library, and using a managed scraping API for production-scale pipelines. Each approach involves different tradeoffs between setup time, maintenance cost, and reliability at scale.

Quick Answer (TL;DR)

Redfin has no public API, so the standard approach is scraping via Python or a managed service. The Redfin API scraper from ScrapingBee handles proxies and JavaScript rendering automatically for production use. Here is what a basic request looks like:

import requests

resp = requests.get(
    "https://www.redfin.com/city/30749/WA/Seattle",
    headers={"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"}
)
print(resp.status_code)

Does Redfin Offer a Public API?

Redfin has no public API. The company has not published a developer portal, documented any endpoints for external use, or offered API keys to third parties. What exists are internal endpoints that Redfin's own web app uses to load listing data; these are JSON responses that a script can technically reach, but they carry no stability guarantees and change whenever Redfin ships a frontend update.

The practical risk is that a scraper built on these endpoints has no warning before it breaks. Redfin does not version its internal API or announce changes to it. For small-scale or one-off data pulls, that tradeoff is often acceptable. For a recurring pipeline, it means building in monitoring and being prepared to update your request parameters when something stops returning data.

Real estate web scraping on Zillow, Realtor.com, and similar platforms involves the same underlying tradeoff between internal endpoint access and long-term reliability.

What Data Can You Scrape from Redfin?

Redfin aggregates listing data from MLS feeds, agent submissions, and public records, making it one of the richer real estate platforms available for scraping. The data falls into several practical categories.

Listing data covers active, pending, and recently sold properties. This is the most common target for scrapers building market analysis tools or investment screening pipelines. Active listings update frequently, and Redfin's sold data is particularly useful because many platforms restrict or obscure historical sales.

Pricing data includes current list price, price reductions, original list price, and the Redfin Estimate, an automated valuation model comparable to Zillow's Zestimate. Price history is available on individual listing pages and is valuable for tracking market movement over time.

Property details include physical attributes like square footage, bedroom and bathroom counts, lot size, year built, and property type. These fields are stable and consistently structured across listings.

Agent and brokerage data appears on most active listings. This is commonly used for lead generation in real estate sales and marketing tools.

Comparable sales are surfaced on individual listing pages alongside the Redfin Estimate, providing localized context for property valuation.

Common Redfin Property Fields

A Redfin property record covers more ground than most listing platforms. The core identification fields (address, city, state, and ZIP) are straightforward. What makes Redfin records useful for analysis is the combination of physical attributes and transaction history in a single record: beds, baths, square footage, lot size, year built, property type, and HOA fees sit alongside listing price, days on market, listing status (active, pending, sold), and price history going back through multiple transactions.

The Redfin Estimate and comparable sales are included on individual listing pages, which makes those pages the right target for valuation work rather than the search endpoint. Agent name and brokerage appear on most active listings and are commonly pulled for lead generation pipelines.

Redfin's sold and price history data is worth calling out specifically. While some other sites restrict much of this behind account gates or API paywalls, on Redfin it is publicly accessible on the listing page.

How to Scrape Redfin Property Data

1. Define your target

Redfin organizes listings by geography, and the URL pattern tells you what level of data you will get back. City-level pages follow /city/{id}/{state}/{city-name}, for example https://www.redfin.com/city/30749/WA/Seattle. ZIP code pages use /zipcode/{zip}. Individual listing pages follow /WA/Seattle/{address}/{id}.

City and ZIP pages are the right starting point for collecting summary data across many properties. Individual listing pages are necessary when you need full detail: price history, the Redfin Estimate, comparable sales, or agent information.

2. Set up your Python environment

Install the core dependencies before writing any requests:

pip install requests pandas beautifulsoup4

If you are scraping HTML pages directly, you will need beautifulsoup4 or lxml to parse the response. If you use Redfin's internal JSON endpoint (covered in step 3), the standard library's JSON module alongside requests is all you need.

3. Find Redfin's internal data endpoint

Redfin loads listing data via an internal API rather than embedding it in the initial HTML response. To find the endpoint, open Chrome DevTools with F12, go to the Network tab, and filter by XHR or Fetch. Load a Redfin city page and watch the requests come in. Look for calls to /stingray/api/gis; these return JSON payloads with the listing data powering the map view. Click one of those requests to inspect the full URL, query parameters, and response structure. The region_id and region_type parameters control which area the results cover.

4. Make the request in Python

With the endpoint and parameters identified, the request is straightforward. Note that Redfin prefixes every JSON response with {}&& to prevent cross-site script inclusion; strip that before parsing:

import requests
import json

url = "https://www.redfin.com/stingray/api/gis"
params = {
    "al": 1,
    "region_id": 16163,  # Seattle
    "region_type": 6,
    "num_homes": 50,
}
headers = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
}

resp = requests.get(url, params=params, headers=headers)

data = json.loads(resp.text.replace("{}&&", ""))
homes = data["payload"]["homes"]

for home in homes[:5]:
    print(home["price"], home["streetAddress"])

5. Parse and store the results

The homes list returned from the payload is already structured, which makes it straightforward to load directly into a DataFrame and write to CSV:

import pandas as pd

df = pd.DataFrame(homes)
df.to_csv("redfin_seattle.csv", index=False)

Each row in the output corresponds to one listing. Column names come from the JSON field names, so you may want to rename or filter columns depending on what your pipeline needs downstream.

6. Scale with a managed API

The approach above works well for one-off pulls and small datasets. For large-scale or recurring collection, ScrapingBee handles proxies, JavaScript rendering, and rate limits automatically. When Redfin updates its internal endpoint structure, the managed API absorbs the change without requiring updates on your end:

import requests

resp = requests.get(
    "https://app.scrapingbee.com/api/v1/store/redfin",
    params={
        "api_key": "YOUR_API_KEY",
        "search": "Seattle, WA",
        "listing_type": "for_sale",
    },
)
data = resp.json()

Common Challenges When Scraping Redfin

JavaScript rendering — Redfin is a React application. Individual listing pages load data dynamically after the initial HTML response, so a plain requests call returns an incomplete page. The internal JSON endpoint sidesteps this for summary data, but individual listing pages often require a headless browser.

Rate limiting and IP blocks — Redfin detects automated access quickly. Without proxy rotation, scrapers receive 403 responses after a small number of requests. The detection threshold is low enough that even moderate collection volumes trigger it.

Data behind interactions — Fields like price history, tax records, and comparable sales load only after a user clicks a tab or scrolls to a section. Capturing these requires either the internal endpoint or a headless browser simulating the interaction.

Endpoint changes — Redfin updates its internal API structure periodically. A scraper built on /stingray/api/gis today may break silently after a frontend deploy. Managed APIs absorb these changes without requiring maintenance on your end.

Redfin Scraping Cost and Usage Limits

The cost of scraping Redfin at scale depends on several factors specific to your collection workflow.

Request volume is the primary driver. A search page returning 50 listings counts as one request. Visiting each listing URL for detailed fields counts as additional requests. Projects needing individual page data for hundreds of listings per day accumulate credits at a different rate than those pulling only summary data.

JavaScript rendering adds cost. Redfin's listing detail pages often require a headless browser to load all fields. Rendered requests consume more credits than plain HTTP requests, so the split between summary and detail pages affects your total usage meaningfully.

Volume tiers reduce per-request cost as usage scales. Daily competitive analysis pipelines have different cost profiles than weekly market snapshots.

Free tier and trial credits are also available. Running the code examples in this guide against a small dataset does not require a paid plan. For current rates across all tiers, see ScrapingBee pricing.

Other Real Estate Sites You Can Scrape

The same API-based scraping approach that works for Redfin applies across major real estate platforms globally. Each platform has its own internal structure, but the workflow is consistent: discover the endpoint, make authenticated requests, parse the JSON, store the output. ScrapingBee's scraper store includes pre-built extractors for major property platforms, each returning structured data through the same API format so you are not rebuilding from scratch for every new market.

Crexi Property Data

The Crexi scraper API returns structured commercial listing data including price, cap rate, square footage, and property type. Crexi is the primary source for U.S. commercial real estate data across office, retail, industrial, and multifamily asset classes. It is widely used in investment screening and portfolio analysis tools that need cap rate comparables, NOI estimates, and broker contact data across multiple U.S. markets. Crexi's commercial coverage is more comprehensive than Redfin's, making it the right data source for any pipeline focused on income-producing properties.

Funda Property Listings

The Funda scraper API covers the Dutch residential market and returns listing price, property type, square footage, energy label, and location data. Funda is the leading residential real estate platform in the Netherlands and the primary source for Western European residential listing data. Investors and researchers targeting EU property markets use it to track price trends, monitor inventory levels, and build localized valuation models. Funda updates listings daily, making it a reliable source for time-series analysis of the Dutch housing market.

Properati Real Estate Data

The Properati scraper API covers residential and commercial listings across Argentina, Colombia, and Ecuador. Properati is one of the primary sources for Latin American property data and is commonly used for cross-border investment research and LATAM market analysis pipelines. Aggregated regional property data for these markets is otherwise difficult to access at scale. Properati provides structured listing data with price, location, and property type fields, making it a practical starting point for analysts and investors building LATAM real estate exposure.

Start Collecting Redfin Data at Scale

There are three ways to move forward from here, depending on how much you need right now.

1. For a quick test, run the internal endpoint code from step 4 against any city region ID. No account or API key required; you will have a working CSV of active listings in a few minutes.
2. For recurring collection, add proxy rotation to avoid 403s and a scheduler to run the script on a weekly or daily cadence. This works well for ongoing market monitoring or investment screening pipelines that do not need to run continuously.
3. For a production pipeline, skip the maintenance entirely and use the managed API from step 6. ScrapingBee handles proxy rotation, JavaScript rendering, and endpoint updates automatically, so your pipeline keeps running regardless of what Redfin changes on the backend. Sign up at scrapingbee.com to get trial credits and test against your target market.

Frequently Asked Questions (FAQs)

Is scraping Redfin legal?

Scraping publicly visible Redfin data is generally accepted for personal and research use. Whether it conflicts with Redfin's Terms of Service depends on how you use the data; their ToS restricts automated access, but ToS violations are a contractual matter, not a criminal one. For commercial applications, get a legal opinion before deploying at scale, since the answer varies by jurisdiction and use case.

How often can I scrape Redfin data?

Redfin updates listing data daily, so daily scraping is the right frequency for active market monitoring, capturing new listings, price changes, and status updates as they happen. For historical analysis and investment screening, weekly pulls are usually sufficient. In practice, the limiting factor is rate limiting rather than data freshness; Redfin starts blocking repeated requests from the same IP quickly.

Does Redfin block bots?

Yes. Redfin actively detects and blocks automated traffic. A basic requests script without the right headers will start returning 403s within a handful of calls, and higher volumes trigger CAPTCHAs and IP-level bans. The standard workarounds are proxy rotation to cycle IP addresses and a managed scraping API that handles detection avoidance automatically.

Can I get historical property data from Redfin?

Redfin shows sold listings and price history on individual property pages, and a scraper can collect this. The constraint is that it requires visiting each listing URL separately rather than pulling from the search endpoint, which adds request volume. There is no bulk historical export available, so building a historical dataset means collecting over time and appending to your own database as new sold records appear.