How to Scrape Redfin in 2026 (API & Python)

Redfin is one of the harder real-estate sites to scrape directly — it doesn't publish a public per-listing API, and its Terms of Use explicitly prohibit automated crawling. The fastest path when you do need structured data is a scraping API that returns normalized JSON for search results, property detail, and Redfin's home-value estimate. This guide covers DIY Python (and why it's especially fragile here), no-code tools, and a structured Redfin API — plus an honest read on reliability, because that's the real question with this platform.

Why scrape Redfin data?

• Home-value / AVM research — the Redfin Estimate alongside property-level and regional price time series, useful as one input among several automated valuation signals.
• Market-trend analysis — median sale price, days on market, and sale-to-list ratio by region, tracked over time.
• Investor and comping tooling — pull comparable homes for a given listing to support deal screening or appraisal workflows.
• AI and data pipelines — feed normalized listing and estimate fields into a model or dashboard instead of hand-copying numbers off listing pages.

Is it legal to scrape Redfin?

Option 1: DIY in Python (and why it breaks)

Redfin renders with heavy JavaScript and layers real bot defenses on top of its no-scraping terms, so a plain requests.get() gets a block page or a stripped-down response almost immediately:

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    page = p.chromium.launch().new_page()
    page.goto("https://www.redfin.com/city/30772/CA/San-Francisco")
    # then find and parse the embedded state JSON, page through map regions,
    # and hope the response isn't a challenge page...

It demos and then breaks, and it breaks in ways that are specifically annoying on Redfin:

• Bot detection in front of the pages you need. Search-results and property pages sit behind challenge/fingerprinting checks; a naive scraper gets a block page instead of data.
• No stable public API to fall back to. Unlike sites with a partner API you can apply for, Redfin's only official data surface is the aggregate Data Center — there's no GET /listings/{id} you're allowed to call instead.
• The embedded JSON shifts. Property and search pages carry a client-state JSON blob whose shape changes without notice, so parsers break silently.
• Reliability isn't guaranteed even once you're past the block. During research for this guide, a live test call against a Redfin scraping endpoint simply timed out — a reminder that "we got past the defenses" and "this will work every time" are different claims on a site this aggressively protected.

Option 2: No-code / ready-made tools

Visual point-and-click extractors can pull a handful of Redfin listing pages for a one-off pull and export CSV/JSON, but they hit the same bot defenses as DIY, tend to be brittle on a protected site like this, and aren't a good fit for a pipeline that needs predictable fields on a schedule.

Option 3: A structured Redfin API

For repeatable workflows, a Redfin scraping API returns normalized JSON with no browser to run — though as above, build for retries rather than assuming every call succeeds. Search for listings by location:

curl -s "https://api.crawlora.net/api/v1/redfin/search?location=San%20Francisco,%20CA" \
  -H "x-api-key: $CRAWLORA_API_KEY"

{
  "code": 200,
  "msg": "OK",
  "data": {
    "location": "San Francisco, CA",
    "page": 1,
    "region_id": 17151,
    "region_type": 6,
    "results": [
      {
        "property_id": "1715020",
        "address": "123 Main St #4",
        "city": "San Francisco",
        "state": "CA",
        "zip": "94110",
        "url": "https://www.redfin.com/CA/San-Francisco/123-Main-St-94110/home/1715020",
        "property_type": "Condo/Co-op",
        "status": "Active",
        "price": 1250000,
        "beds": 2,
        "baths": 2,
        "sqft": 1100,
        "lot_size": 2500,
        "year_built": 1998,
        "days_on_market": 7,
        "price_per_sqft": 1136,
        "hoa_monthly": 450,
        "mls_number": "424001234",
        "latitude": 37.7596,
        "longitude": -122.4269
      }
    ]
  }
}

Fetch a single property by ID in Python, then pull its home-value estimate and comparable homes:

import requests

h = {"x-api-key": "YOUR_API_KEY"}
base = "https://api.crawlora.net/api/v1/redfin"

prop = requests.get(f"{base}/property", headers=h, params={"property_id": "1715020"}).json()["data"]
print(prop.get("address"), prop.get("city"), prop.get("state"))

estimate = requests.get(f"{base}/estimate", headers=h, params={"property_id": "1715020"}).json()["data"]
print(estimate.get("estimate_text"), "vs listing price", estimate.get("listing_price"))

similar = requests.get(f"{base}/similar", headers=h, params={"property_id": "1715020"}).json()["data"]
print(len(similar.get("results", [])), "comparable homes")

The estimate endpoint returns the Redfin Estimate alongside property, city, county, and ZIP price time series (fields are illustrative — check the docs):

{
  "code": 200,
  "msg": "OK",
  "data": {
    "property_id": "1715020",
    "estimate": 1850000,
    "estimate_text": "$1.85M",
    "listing_price": 2500000,
    "address": "1242 Sacramento St #1",
    "beds": 2,
    "baths": 2,
    "sqft": 1609,
    "year_built": 1900,
    "property_time_series": [1800000, 1820000, 1850000],
    "city_time_series": [1500000, 1510000, 1520000],
    "county_time_series": [1400000, 1410000, 1420000],
    "postal_code_time_series": [1523302, 1529750, 1537670]
  }
}

For market-level context, region-trends returns median prices and inventory for a region ID (resolved via a prior search call):

curl -s "https://api.crawlora.net/api/v1/redfin/region-trends?region_id=17151&region_type=6" \
  -H "x-api-key: $CRAWLORA_API_KEY"

{
  "code": 200,
  "msg": "OK",
  "data": {
    "region_id": 17151,
    "region_type": 6,
    "median_list_price": "$1.29M",
    "median_sale_price": "$1.76M",
    "median_sale_per_list": "115.5%",
    "avg_days_on_market": "31",
    "num_homes_sold": "568",
    "num_homes_on_market": "978",
    "yoy_sale_price": "+14.0%"
  }
}

What you can collect

Where the public listing and market pages expose them: address, city/state/zip, price, beds, baths, sqft, lot size, year built, days on market, price per sqft, HOA, MLS number, and coordinates from search; description and facts from property detail; the Redfin Estimate and price time series from estimate; comparable homes from similar; and median price, inventory, days-on-market, and sale-to-list ratio from region trends.

Limitations

• No official per-listing API. The only sanctioned Redfin data surface is the aggregate Data Center (metro/ZIP CSVs); anything at the property level is unofficial by definition.
• Terms of Use explicitly prohibit automated crawling. This isn't just a technical defense — Section 2.3.5 bans scraping outright without prior written permission.
• Reliability varies, and can vary a lot. Redfin's defenses mean any given call — DIY or via a structured API — can time out or get blocked; don't build a pipeline that assumes 100% success, and add retry/backoff.
• Listing media is copyrighted. Photos and agent-written descriptions carry copyright separate from the underlying facts — don't republish them.
• The Redfin Estimate is a model, not ground truth. Treat it as one signal among several, same as any automated valuation model.
• Status and prices change fast. Active/pending/sold flips quickly, so a snapshot goes stale — re-collect on a schedule if you need current state.

Where this gets used

• Home-value and comping research — combine the estimate and similar-homes endpoints to sanity-check a valuation.
• Market-trend tracking — pull region trends on a schedule to watch a metro's median price, inventory, and days-on-market move.
• Investor and appraisal tooling — feed normalized listing and estimate fields into deal-screening or valuation workflows.

Sources

Start collecting

Try it first, free: run any public URL through the Free Web Scraper, or check whether a site blocks bots with the Anti-Bot Checker — no signup.

Test the search endpoint in the Playground, check the schema in the API docs, and review pricing. For a single-portal deep dive on Redfin's biggest competitor, see how to scrape Zillow; to cover Zillow, Redfin, Realtor.com, and Trulia together, see how to scrape real estate listings and the broader real estate data API use case; and for the legal basics that apply across every site, is web scraping legal.

Part of our how-to-scrape guide series — every platform we cover, in one index.