Redfin Has No Public API: Export US Property Data in 2026

If you went looking for a Redfin developer portal, you already know how this story ends: there isn’t one. Redfin has no public API. There’s no developer signup, no API key, no documented endpoints, no rate card. What it does have is a “Download All” CSV button on search-results pages and a fast, JSON-driven frontend. So when someone googles “Redfin API” they’re really asking the same question this guide answers — how do you export US property data from Redfin in 2026 when the only sanctioned export is a button that downloads the current page? The answer lives in the internal endpoints that button quietly hits.

The API gap, precisely

Redfin’s public-facing data philosophy is “browse it, don’t ingest it.” The site is generous about showing you listings — active for-sale, sold history, price drops, days on market, school data, the lot — but it gives you no programmatic, documented way to pull that at scale.

The one official export is the CSV download on a search page. It dumps the listings currently matching your filters and viewport into a flat file: address, price, beds, baths, square footage, lot size, year built, days on market, the listing URL, latitude/longitude, and a few more columns. It’s real, structured data — but it’s per-search, per-viewport, and capped (the download tops out at a few hundred rows per page of results). It’s a convenience feature, not a feed.

There is no documented JSON API behind a key. So “Redfin has no public API” is literally true, and any data-export workflow has to work with the site’s own internal surface — the same one your browser uses.

What data is actually available

Despite the missing API, the data on Redfin is rich and worth pulling:

• Listing core — address, city, state, zip, price, status (active / pending / sold), beds, baths, square footage, lot size, year built.
• Market signals — days on market, price-per-square-foot, price history and price drops, sale-to-list ratio on sold homes.
• Geo — latitude, longitude, neighborhood, MLS number where shown.
• Sold history — for closed transactions, the sale price and sale date, which is the most valuable part for comps and analytics.
• Property detail — HOA dues, property type, parking, and the photo set on individual listing pages.

The CSV button gives you a good slice of the listing core. The detail-level fields come from the individual property pages.

How the public surface actually works

Redfin’s frontend is a single-page app fed by internal JSON endpoints under the stingray path — that’s the service name you’ll see in the network tab. The search map and results are driven by gis and gis-csv style endpoints that take a region, a viewport bounding box, and the active filters, and return either JSON for the map or CSV for that download button.

Mechanically, the flow looks like this:

• Resolve the region. Redfin keys searches to an internal region ID (a city, zip, or neighborhood maps to a numeric region). The site resolves your text query to that ID first.
• Query the GIS endpoint. With a region ID, filters (price, beds, status, property type), and a map bounding box, the GIS endpoint returns the matching listings as JSON for the map pins, or the gis-csv variant returns the same set as the downloadable CSV.
• Paginate by viewport and filter. Because results are capped per response, broad areas have to be split — by smaller bounding boxes or tighter filters — to walk the whole inventory. This is the real engineering: you don’t paginate with a cursor, you subdivide geography.
• Fetch detail pages. For the deep fields (price history, HOA, full sold record), you hit the individual listing URL and parse the embedded JSON the page ships with its initial render.

These are internal, undocumented endpoints. They aren’t a stable contract — Redfin can and does change them — and that’s exactly why “no public API” matters: there’s no versioning or support, so anything built on them needs to expect drift.

Rate limits and how to live with them

There’s no published rate limit because there’s no published API. Practically, Redfin runs standard anti-abuse protections, and a residential-grade frontend that suddenly fires hundreds of GIS requests a minute from one datacenter IP will get throttled or served a challenge. The working posture:

• Keep concurrency modest and add jitter between requests.
• Subdivide large regions into reasonable bounding boxes rather than asking for an enormous viewport in one shot.
• Cache the region-ID resolution so you’re not re-resolving the same city repeatedly.
• Treat 403/429 responses as a signal to back off, not to retry harder.

The per-response cap (a few hundred rows) is itself a rate limiter in disguise — it forces geographic subdivision, which naturally spreads load.

A clean output schema

Flatten listings into a consistent per-property record:

{
  "address": "123 Example St",
  "city": "Seattle",
  "state": "WA",
  "zip": "98103",
  "price": 875000,
  "status": "active",
  "beds": 3,
  "baths": 2.5,
  "sqft": 1840,
  "lot_size_sqft": 4000,
  "year_built": 1998,
  "price_per_sqft": 475,
  "days_on_market": 12,
  "hoa_monthly": null,
  "property_type": "Single Family Residential",
  "latitude": 47.6731,
  "longitude": -122.3415,
  "mls_number": "2241567",
  "last_sold_price": 690000,
  "last_sold_date": "2019-06-01",
  "listing_url": "https://www.redfin.com/WA/Seattle/123-Example-St-98103/home/12345678",
  "scraped_at": "2026-06-04T00:00:00Z"
}

Schema notes:

• Status is a tight enum — active, pending, sold, coming-soon. Map Redfin’s labels at extraction.
• Sold fields are nullable on active listings, and active-market fields (days on market) are nullable on sold ones. Don’t force every field onto every row.
• Keep mls_number when present — it’s the cross-source join key to other listing data.
• Store lat/long — half the use cases are geospatial.
• Always stamp scraped_at — prices and statuses change daily; a record without a timestamp is unusable for trend work.

▶ Try the Redfin Scraper on Apify — exports active, pending and sold US listings by region into flat JSON or CSV, handling the region-ID resolution and viewport subdivision for you. No API key, because Redfin doesn’t offer one.

Use cases

• Comparable-sales analysis — sold price and date by neighborhood for valuation models.
• Investor deal sourcing — filter by price-per-square-foot, days on market and price drops to surface motivated sellers.
• Market dashboards — track median price, inventory and DOM by metro over time.
• Lead generation — agents and lenders prospecting new and stale listings.
• Property data enrichment — augment an existing address dataset with beds, baths, sqft and last sale.

Build it yourself vs. a managed scraper

You can build this. Resolve regions, walk the GIS endpoints, subdivide viewports to beat the per-response cap, parse detail pages for the deep fields, add backoff and proxying, and keep up with the internal endpoint drift. It’s a couple of weeks to a solid pipeline and ongoing maintenance whenever Redfin reshapes its frontend. For a one-time pull of one metro, the CSV button plus a little scripting is fine. For a recurring, multi-region feed, a managed actor absorbs the subdivision logic and the maintenance churn and hands you normalized rows.

Common pitfalls

• Assuming the CSV button is the whole dataset. It’s the current page, capped. Deep fields need the detail pages.
• Querying one giant viewport. You’ll hit the per-response cap and silently miss listings. Subdivide.
• Treating the internal endpoints as stable. They’re undocumented; expect drift and design for it.
• Hammering from one datacenter IP. Modest concurrency and residential egress avoid challenges.
• Dropping the timestamp. Real estate data is only as good as its freshness.

Wrapping up

Redfin has no public API and isn’t going to ship one — the official export is a per-page CSV button, and everything richer runs through the internal stingray/GIS endpoints that the site itself uses. Exporting US property data from Redfin in 2026 means resolving region IDs, subdividing viewports to beat the per-response cap, and parsing detail pages for the deep fields, all while respecting modest rate limits and accepting that the endpoints can change. Do it yourself for a one-metro snapshot, or use a managed scraper that handles the geography and the drift for a recurring feed.

▶ Open the Redfin Scraper on Apify — region-based US property export with sold history, price drops and geo, normalized and ready for your comps model. No developer key required.