Is There a Redfin API? How to Get Redfin Listing Data

Search "Redfin API" and the results look encouraging. There's a Python package literally named redfin on PyPI. There are RapidAPI collections, GitHub repos with a few hundred stars, and a dozen blog posts confidently titled "Redfin API Documentation." What you will not find anywhere in those results is a link to a Redfin developer portal, because there isn't one.

Here's the honest version of the answer, plus the part most articles skip: what you can actually run today.

The short answer

No. Redfin has no public API. No developer program, no documented endpoints for third parties, no key to request, no sandbox. Every "Redfin API" in your search results is one of three things: a wrapper somebody reverse-engineered from the website, a scraper marketplace listing, or a hosted provider (this site is one) that absorbs the hard part on your behalf.

That leaves five realistic options in 2026, and they differ enormously in cost, effort, and how often they page you at 2am. One of them is free and official but returns no listings at all. One of them is a REST call you can make this afternoon. Before the comparison, it's worth understanding why the official door is shut, because that reasoning tells you which workarounds are stable and which are living on borrowed time.

Why Redfin doesn't hand out API keys

The usual assumption is that Redfin is a data company being stingy. It isn't. Redfin is a licensed real estate brokerage that happens to run a very good website. It gets listing data the same way any brokerage does: by joining local MLSs as a participant and ingesting their feeds.

That distinction is the whole answer. Under the National Association of Realtors' IDX policy, a participant displaying MLS data may not distribute or make any portion of the MLS database available to another person or entity outside the approved display uses. Most of the inventory on redfin.com is not Redfin's to redistribute. An official listings API wouldn't be a product decision so much as a licensing renegotiation with hundreds of MLSs at once.

Then there's the business model. Redfin's site exists to turn visitors into transactions with Redfin agents, and since Rocket Companies completed its all-stock acquisition of Redfin on July 1, 2025 in a deal valued around $1.75 billion, that funnel also feeds a mortgage lender. Nobody spends $1.75 billion on a funnel and then pipes it out for free. Yeah… no. That API was never coming.

What Redfin does publish, generously, is aggregate market data. The Redfin Data Center offers free downloadable housing-market datasets from national level down through metro, county, city, ZIP code, and neighborhood: median sale price, homes sold, new listings, inventory, days on market, price drops. It also hosts dashboards for migration patterns, investor purchases, delistings, and the Redfin Home Price Index. Redfin's own walkthrough covers what's in there:

If your project needs trends, start there. It is free, official, and nobody will ever block your IP for downloading it. But aggregates answer a different question than the one most developers are actually asking. The Data Center will tell you the median sale price in a ZIP code last month. It will not tell you which three-bedrooms are listed there right now, which of them cut their price in the last week, or what the Redfin Estimate says about the one your user just bookmarked. For that, you need listing-level access.

Your five real options in 2026

Every route to Redfin listing data trades money against engineering time against fragility. The honest comparison:

Option	Pricing	Setup effort	Where it hurts
Official Redfin API	Doesn't exist	n/a	There is nothing to sign up for. Every result promising one is somebody else's wrapper wearing Redfin's name.
Redfin Data Center (official)	Free	Minutes	Aggregated market statistics only. No listing records, no per-property detail, no live inventory.
DIY scraper (headless browser + proxies)	"Free," plus proxies and your time	Days to build, forever to maintain	Redfin's internal JSON is undocumented and unversioned, so it changes without notice. Rate limiting shows up early, 403s and CAPTCHAs follow, and the terms of use prohibit automated collection.
Scraper marketplaces (e.g. Apify actors)	From about $1 per 1,000 results	Hours	You still own schemas, dedup, retries, and monitoring. Redfin's own search view caps how many pages you can walk, so vendors subdivide the map to get past it and you inherit whatever that costs in runs.
Unofficial open-source clients (e.g. the reteps Python wrapper)	Free	Hours	Reverse-engineered from Redfin's internal endpoints. It's genuinely well built, down to honouring `Retry-After` on 429s, but nothing about it is sanctioned and there is nobody to email when it stops.
Hosted REST endpoints (RealtyAPI)	Free tier of 250 requests/month; plans from $20/month for 20,000 requests at the time of writing	Minutes	Coverage tracks what Redfin itself publishes, so it's US-only, and a couple of the convenience endpoints bill more than one request per call.

If you're seriously weighing the build-it-yourself route, we've laid out the general trade-off in web scraping vs. using an API. Short version: scraping wins when the data has no API at any price and your volume is small enough to babysit. It loses the moment uptime matters or somebody else depends on your pipeline.

Is scraping Redfin legal?

The question everyone asks quietly. The unsatisfying answer: scraping publicly visible pages is not automatically illegal in the United States, but Redfin's terms of use prohibit scraping and automated collection, and there is now a mortgage lender's legal department standing behind that. Courts have gone back and forth on public-data scraping for years, and none of that ambiguity makes your Tuesday deploy more reliable when the bot wall tightens. We cover the landscape properly in is website scraping legal? and explain how we approach sourcing in how RealtyAPI sources data. The practical read: legal risk is real but ambiguous, while the maintenance pain is certain. Most teams don't abandon scrapers because a lawyer called. They abandon them because the fourth selector change in a month landed on a Friday.

What RealtyAPI's Redfin endpoints cover

RealtyAPI runs hosted Redfin endpoints as part of its real estate data platform: you call a normal REST endpoint with an API key, and proxies, retries, and anti-bot plumbing stop being your problem. There are 31 endpoints across four families.

Infographic: one RealtyAPI key connects to four Redfin endpoint families - property search, property details, property insights, and market data

Endpoint	What it returns
`GET /autocomplete`	Location matches for a free-text query, with the region ids search accepts
`GET /search/bylocation`	Listings for a city, neighborhood, or ZIP, with the full filter set below
`GET /search/bypolygon`	Listings inside an arbitrary lat/lng polygon, for map-drawn searches
`GET /search/bycoordinates`, `/search/byurl`, `/search/byregionid`	The same search, keyed off a point, a Redfin URL, or a region id
`GET /detailsbyurl`, `/detailsbyid`, `/detailsbyaddress`	Full property record, addressed three different ways
`GET /avm`	The Redfin Estimate for a property
`GET /housingMarketTrends`	Time series for a region: median sale price, homes sold, days on market, sale-to-list, above-list, price drops
`GET /usHousingMarketTrends`	National figures in three blocks: overview, supply, demand
`GET /marketHotness`	Redfin Compete Score for a region, plus a nearby-ZIP comparison
`GET /climateRisk`	First Street flood, fire, wind, and heat factors for a region
`GET /schools`	Elementary, middle, and high schools with GreatSchools ratings
`GET /recentlySold`	Recently sold homes in a region, up to 350 per call

The rest fill in the property page piece by piece: /walkScore, /floodInfo, /amenities, /agentInfo, /priceDropInfo, /insights, /mortgageCalculatorInfo, /hotMarketInfo, and friends. Auth everywhere is a single x-realtyapi-key header, and responses are JSON.

The filters that make it feel like Redfin

Generic national listing APIs give you beds, baths, and price, which is exactly how you end up unable to answer "three-bed under $750k that dropped its price this week, in a decent school zone, no HOA over $200." Search takes the filters Redfin users actually click:

searchType: For_Sale, For_Rent, or Sold, with soldWithin reaching back as far as Last_5_Years
priceReduced: price cuts within the last day, week, fortnight, month, or longer
timeOnRedfin: from New_listings through More_than_180d, which is how you find the stale inventory sellers are quietly tired of
walkScore, transitScore, bikeScore: threshold filters like 70plus
greatSchoolsRating plus schoolTypes: rating floors, optionally scoped to elementary, middle, or high
HOAfees, propertyTaxes, minPricePerSQFT, maxMonthlyPayment: the carrying-cost filters that decide whether a listing is actually affordable
status, listingType, acceptedFinancing (FHA/VA), excludeShortSales, hasFixerUpper: the deal-shape filters investors live in
pets, moveInDate, hasDeals, amenitiesRentalProperties: the rental side
keyword: free-text against listing descriptions, for when your users search like humans

Quick-start: Redfin listings in three requests

Base URL: https://redfin.realtyapi.io. Auth: your key in the x-realtyapi-key header. Forget the header and the gateway is blunt about it:

{"error":"Missing API key in the header"}

Redfin is part of the standard API set rather than a premium add-on, so the free plan's 250 requests a month is enough to work through everything below before you decide anything. The docs cover key setup in about two minutes.

Diagram of the three-request flow: find the location, search listings, then get details for one home

1. Resolve the location

curl "https://redfin.realtyapi.io/autocomplete?query=Austin&listingStatus=For_Sale_or_Sold" \
  -H "x-realtyapi-key: YOUR_KEY"

Matches come back grouped under sections, and each row carries an id. That id is the regionId the region-scoped and polygon searches expect, so this call is your source of truth for what Redfin will recognise. Plain city names work directly in the location search below, so you can skip this step once you know the strings you need.

2. Search

curl "https://redfin.realtyapi.io/search/bylocation?locationName=Austin&locationSubName=TX&searchType=For_Sale&minBeds=Three&maxPrice=750000&priceReduced=Less_than_7d&resultCount=100" \
  -H "x-realtyapi-key: YOUR_KEY"

Homes come back under searchResults. Page size is resultCount, defaulting to 100 and topping out at 1,000, and each response carries a nextPage boolean. Keep incrementing page until it flips to false. Each page is one request against your quota, which is worth remembering before you set resultCount=1 and paginate ten thousand times.

3. Get the details

curl "https://redfin.realtyapi.io/detailsbyurl?property_url=https://www.redfin.com/NY/Saint-Albans/10970-203rd-St-11412/unit-I/home/20739181" \
  -H "x-realtyapi-key: YOUR_KEY"

The shortened path form (/NY/Saint-Albans/10970-203rd-St-11412/unit-I/home/20739181) works too, which matters because that's the shape search results hand you. If all you have is a street address, /detailsbyaddress takes it, at a documented cost of two requests per call and noticeably slower responses. Use it for the one-off lookup, not for a batch job.

A production-ish Python loop

Here's the same flow with pagination and the error handling you actually want, because any API fronting live web data will occasionally have a bad minute upstream:

import requests

BASE = "https://redfin.realtyapi.io"
HEADERS = {"x-realtyapi-key": "YOUR_KEY"}

def get(path, **params):
    r = requests.get(BASE + path, params=params, headers=HEADERS, timeout=60)
    if r.status_code == 401:
        raise RuntimeError("Bad or missing x-realtyapi-key")
    r.raise_for_status()
    return r.json()

def search(**filters):
    page = 1
    while True:
        data = get("/search/bylocation", page=page, resultCount=100, **filters)
        homes = data.get("searchResults") or []
        if not homes:
            break
        for home in homes:
            yield home
        if not data.get("nextPage"):
            break
        page += 1

for home in search(locationName="Austin", locationSubName="TX",
                   searchType="For_Sale", minBeds="Three",
                   maxPrice="750000", priceReduced="Less_than_7d"):
    print(home)

Two things worth stealing from that loop even if you use a different provider. Treat an empty result set as a stop condition alongside the pagination flag, because a truthy flag with nothing behind it will spin forever. And separate 401 from the general failure path, since a bad key looks exactly like a bad Tuesday if you lump every non-200 together. Ask me how I know.

From there it's your product: diff daily snapshots into Postgres for a price-drop alert bot, join walkScore thresholds against commute times for a relocation tool, or pull Sold searches with soldWithin=Last_1_Year to build comps. The point of an API over a scraper is that this loop is the whole integration. There's no proxy pool underneath it for you to feed.

Beyond listings: trends, climate risk, and schools

This is the part scraper comparisons skip, and it's usually where the interesting product lives. A listing tells you what a house costs. The region endpoints tell you whether that price makes sense.

Infographic: market trends, climate risk, schools, and walk score data alongside listings

All three take the same free-form location string, so a ZIP code, a city, a county, a neighborhood, or a raw region id all work:

# Time-series market trends for one ZIP, condos only
curl "https://redfin.realtyapi.io/housingMarketTrends?location=78704&propertyType=Condos" \
  -H "x-realtyapi-key: YOUR_KEY"

# First Street climate factors: flood, fire, wind, heat
curl "https://redfin.realtyapi.io/climateRisk?location=78704" \
  -H "x-realtyapi-key: YOUR_KEY"

# Schools with GreatSchools ratings, by level
curl "https://redfin.realtyapi.io/schools?location=78704" \
  -H "x-realtyapi-key: YOUR_KEY"

Climate data has quietly become a pricing input, not a nice-to-have. Flood and fire factors move insurance quotes, insurance quotes move carrying costs, and carrying costs move what a buyer can bid. If you're building anything that estimates affordability, pulling /climateRisk alongside the listing costs you one request and saves your users a discovery they'd rather not make after closing. /marketHotness is the other underrated one: it returns the Redfin Compete Score for a region with a nearby-ZIP comparison, which is a cheap way to label a market "competitive" without building your own model on day one.

What you still can't get

Honesty section, because a comparison table that only lists other people's limitations isn't a comparison. These endpoints return what Redfin publishes now: active and recently sold listings, their details, current filters, current regional aggregates. They are not an archive. If you need multi-year price history per property, you capture snapshots yourself on a schedule (the loop above plus a cron job and a database gets you further than you'd expect) or you lean on the free Data Center for aggregate history.

Coverage is Redfin's coverage, which means the United States, and it means MLS-participant fields as displayed publicly rather than the full MLS record an agent sees. And if your app needs anything outside the US, or a second source to reconcile against, that's a job for pairing portals, which is how we approached both getting StreetEasy data for New York and pulling property data from Zillow. If you're still choosing between providers generally, our comparison of real estate listing APIs puts the options side by side with pricing.

Key takeaways

Redfin has no public API, and it's structural rather than an oversight. Redfin is a brokerage displaying MLS data under IDX rules that forbid redistribution, so most of the inventory simply isn't Redfin's to hand out.
For aggregate trends, the Redfin Data Center is free and official. Median sale price, inventory, days on market, and migration data down to ZIP level, with no engineering and no legal grey area.
DIY and marketplace scrapers trade money for maintenance. A dollar per thousand results looks cheap until you're the one reconciling schemas and working around a search view that caps out well short of the whole market.
Hosted endpoints turn the problem into one HTTP call. Search by location, polygon, or URL, then details, estimates, schools, climate risk, and market trends, all behind a single header.
Whatever route you pick, keep the integration one layer thick. If a source changes, you want to swap one client file, not an application's worth of parsing assumptions.

The fastest way to find out whether Redfin data fits your product is to run the three requests above against your own market. The free plan's 250 requests costs nothing and answers the question in an afternoon, which beats a week of building a scraper to learn the same thing.