Skip to content

Scraping Redfin Property Data: Endpoints, Python, and Scale

Redfin is one of the richer public real estate sources, but it has no developer API. The data you want sits behind internal endpoints used by Redfin's own frontend, which means you can reach it, but you also inherit the maintenance. This guide walks through the three realistic collection paths — internal JSON, a Python scraper, and a managed scraping API — and shows which fields live where so you can pick the right target before writing code.

What Redfin actually exposes

There is no documented Redfin API, no developer portal, and no API keys issued to third parties. What exists are internal JSON responses that power the Redfin web app. They are technically reachable, but they carry no stability guarantees and can change whenever Redfin ships a frontend update. For a one-off pull that tradeoff is usually fine. For a recurring pipeline it means monitoring and a willingness to update request parameters when responses stop returning data. The same endpoint-vs-reliability tradeoff shows up on Zillow, Realtor.com, and similar platforms.

Fields worth collecting

Redfin aggregates MLS feeds, agent submissions, and public records, so a single property record can combine identification, physical attributes, and transaction history. The practical categories are:

  • Listing status: active, pending, recently sold.
  • Pricing: current list price, price reductions, original list price, and the Redfin Estimate (an automated valuation model comparable to Zillow's Zestimate).
  • Physical attributes: square footage, beds, baths, lot size, year built, property type, HOA fees.
  • Transaction context: days on market, price history across multiple transactions, comparable sales.
  • Agent and brokerage: present on most active listings and commonly used for lead generation.

One distinction matters for targeting: summary fields come back from the search endpoint, but the Redfin Estimate, comparable sales, and full price history sit on individual listing pages. If your goal is valuation work, plan to visit listing URLs rather than only the search endpoint. Redfin's sold and price history data is publicly accessible on the listing page, which is not true of every platform.

Choosing your target URL

Redfin organizes listings by geography, and the URL pattern tells you what you will get back:

  • City pages: /city/{id}/{state}/{city-name}, e.g. https://www.redfin.com/city/30749/WA/Seattle
  • ZIP pages: /zipcode/{zip}
  • Individual listings: /WA/Seattle/{address}/{id}

Use city and ZIP pages when you want a broad sweep of summary records across a market. Switch to individual listing URLs whenever the fields you need — price history, the Redfin Estimate, comparable sales, or agent details — only appear on the property's own page.

Python setup and the internal endpoint

Install the core dependencies first. If you parse HTML directly you will need beautifulsoup4 or lxml; if you use the internal JSON endpoint, requests plus the standard json module is enough.

To find the endpoint, open Chrome DevTools (F12), go to the Network tab, filter by XHR or Fetch, and load a Redfin city page. Look for calls to /stingray/api/gis — these return JSON payloads with the listing data powering the map view. Inspect the full URL, query parameters, and response structure. The region_id and region_type parameters control which area the results cover.

A working request for Seattle looks like this (see the supplied code module for the exact script). Note that Redfin prefixes every JSON response with {}&& to prevent cross-site script inclusion; strip that prefix before parsing. The payload's homes list is already structured, so you can load it directly into a pandas DataFrame and write to CSV. Column names come from the JSON field names, so rename or filter as your downstream pipeline needs.

Common failure modes, and how to tell them apart

Three different problems produce three different symptoms, and mixing them up wastes debugging time:

  • 403 responses after a small number of requests: rate limiting or IP blocking. Redfin detects automated access quickly; without proxy rotation even moderate volumes trigger it.
  • Incomplete HTML from a plain requests call: JavaScript rendering. Redfin is a React application and listing pages load data dynamically after the initial response. The internal JSON endpoint sidesteps this for summary data, but listing pages often require a headless browser.
  • Empty or missing fields that used to work: an endpoint change. Redfin updates its internal API structure periodically and does not version or announce changes. A scraper built on /stingray/api/gis today may break silently after a frontend deploy.

A fourth case is fields that only exist behind an interaction — price history, tax records, and comparable sales load after a user clicks a tab or scrolls. Capturing those requires either the internal endpoint or a headless browser simulating the interaction.

Cost and usage drivers

Cost scales with request volume and rendering, not with the number of listings alone. A search page returning 50 listings counts as one request; visiting each listing URL for detail fields counts as additional requests. JavaScript rendering adds cost because rendered requests consume more credits than plain HTTP requests, so the split between summary and detail pages meaningfully affects total usage. Volume tiers reduce per-request cost as usage scales, and daily competitive analysis pipelines have different cost profiles than weekly market snapshots. Free tier and trial credits are available; run the examples against a small dataset before committing to a paid plan.

When a managed API is the right call

The internal-endpoint approach works well for one-off pulls and small datasets. For large-scale or recurring collection, a managed scraping API handles proxies, JavaScript rendering, and rate limits automatically. When Redfin updates its internal endpoint structure, the managed service absorbs the change without requiring updates on your end. The exact request contract for the managed Redfin scraper is preserved in its protected module; refer to that module for the endpoint, parameters, and authentication fields rather than reconstructing them.

The same API-based approach applies across other real estate platforms. Each has its own internal structure, but the workflow is consistent: discover the endpoint, make authenticated requests, parse the JSON, store the output. Pre-built extractors exist for Crexi (U.S. commercial: price, cap rate, square footage, property type), Funda (Dutch residential: price, property type, square footage, energy label, location), and Properati (Argentina, Colombia, Ecuador residential and commercial listings).

A short decision checklist

Use this to choose a path before writing code:

  • One-off pull or small dataset: run the internal endpoint code against a city region_id. No account or API key required.
  • Recurring collection with moderate volume: add proxy rotation to avoid 403s and a scheduler for weekly or daily runs. This suits ongoing market monitoring or investment screening that does not need continuous operation.
  • Production pipeline: use the managed API so proxy rotation, JavaScript rendering, and endpoint updates are handled for you.
  • Valuation work: target individual listing pages, not the search endpoint, because the Redfin Estimate and comparable sales live there.
  • Historical dataset: expect to accumulate over time. There is no bulk historical export; you collect sold records as they appear and append to your own database.

Frequently asked questions

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 watches for automated traffic and shuts it down. A plain requests script that sends no browser-like headers typically gets 403 responses after only a few calls, and heavier request volumes bring on CAPTCHA challenges and bans at the IP level. Two common ways around this are rotating proxies so requests come from different IP addresses, and a managed scraping API that takes care of detection avoidance on your behalf.

Can I get historical property data from Redfin?

Sold listings and price history do appear on each property's own page, so a scraper can gather them. The catch is that you have to open every listing URL one by one instead of reading them off the search endpoint, which drives up request volume. No bulk historical export exists, so assembling a historical dataset means harvesting over time and appending each newly sold record to your own database as it shows up.