Redfin Scraper API

Real estate · v1.1.0 · redfin_search

$0.0008 / listing

$0.80 / 1K · pay per delivered listing

A Redfin scraper API that takes a US ZIP code and returns its for-sale listings: full address split into fields, price, beds, baths, living area, lot size, property type, status, MLS id, coordinates, photo and the listing URL. One fetch returns everything the region’s API gives up — up to 350 homes where the visible page shows 41 — with none of the advertisement cards mixed in.

By Aldo Morese, founder of QuanticData · Published Aug 21, 2026 · Updated Sep 3, 2026

Run in dashboard See the request

$0.0008 per delivered listing · $2 free every month · Failed runs never billed

What it does

What a Redfin scraper API does

Redfin server-renders the replies to the API calls its page would otherwise make from the browser, and the listings sit in that embedded cache under the region’s GIS entry. That is the whole reason this collector is cheap: a single fetch carries every home the region will return, so there is no pagination to walk. The DOM would need nine page fetches for the same rows and would hand back advertisement cards among them and carousel images misaligned against listings; the JSON contains neither.

The cache is guarded the classic way — every value is prefixed with {}&& so it is invalid JavaScript to a script include — and has to be stripped before parsing rather than parsed around. Fields arrive wrapped as { value, level }, where level is an access flag for Redfin’s own tiering; the collector reads value on every field and delivers coordinates, MLS id and lot size exactly as the API states them.

Inputs

The whole request. Anything you leave out falls back to the default shown in the catalog.

Input	Type	Required	What it does
`location`	string	yes	US ZIP code, e.g. "78701". A full address containing a ZIP works too — the ZIP is what Redfin keys on.
`country`	string	no	ISO 3166-1 alpha-2 code — proxy exit geo and Google locale (gl). Omit for the default pool.
`max_results`	integer	no	How many listings to deliver at most (1–350). You pay only for delivered listings.

Outputs — 42 fields, one row per listing

What one listing looks like

Every delivered listing carries these fields. Nullable means the source did not publish it — the field stays empty instead of being guessed.

Field	Type	What it holds
`rank`	integer	1-based position in Redfin's order.
`mls_id`	string · nullable	MLS listing id.
`address`	string · nullable	Full address on one line.
`street`	string · nullable	Street line, including unit when present.
`city`	string · nullable	City.
`state`	string · nullable	State code.
`zipcode`	string · nullable	ZIP code.
`price`	number · nullable	Asking price. Null on Coming Soon listings, which have none yet.
`beds`	number · nullable	Bedrooms.
`baths`	number · nullable	Bathrooms, half baths included (e.g. 4.5).
`area_sqft`	number · nullable	Living area in sqft. Null on land.
`lot_size`	number · nullable	Lot size. Null on condos.
`property_type`	string · nullable	House, Condo/Co-op, Townhouse, Multi-Family or Land.
`status`	string · nullable	MLS status (Active, Coming Soon, New…).
`latitude`	number · nullable	GPS latitude.
`longitude`	number · nullable	GPS longitude.
`listed_by_redfin`	boolean	Brokered by Redfin itself. Descriptive, not a sponsored placement.
`image`	string · nullable	Primary photo URL, built from the listing's ids the way Redfin builds it.
`url`	string · nullable	Listing page URL.
`property_id`	string · nullable	Redfin property id — the number at the end of the listing URL.
`listing_id`	string · nullable	Redfin listing id.
`neighborhood`	string · nullable	Subdivision or neighbourhood name as Redfin files it.
`price_per_sqft`	number · nullable	Asking price per square foot.
`hoa_monthly`	number · nullable	Monthly HOA dues in USD when stated.
`year_built`	integer · nullable	Year built.
`days_on_market`	integer · nullable	Days on market.
`stories`	number · nullable	Number of stories when stated.
`full_baths`	integer · nullable	Full bathrooms.
`partial_baths`	integer · nullable	Partial bathrooms.
`garage_spaces`	integer · nullable	Garage spaces.
`parking_spaces`	integer · nullable	Parking spaces.
`photo_count`	integer · nullable	Number of photos on the listing.
`last_sold_date`	string · nullable	Date of the previous recorded sale (YYYY-MM-DD).
`open_house_start`	string · nullable	Next open house start (ISO 8601, UTC).
`open_house_end`	string · nullable	Next open house end (ISO 8601, UTC).
`labels`	string[] · nullable	Ribbons on the card, e.g. "New", "Open House", "3D Walkthrough".
`key_facts`	string[] · nullable	Short highlights Redfin extracts from the listing.
`tags`	string[] · nullable	Listing tags, e.g. "GRANITE COUNTERS".
`description`	string · nullable	Listing remarks, up to 1,500 characters.
`is_hot`	boolean · nullable	True when Redfin flags the listing a Hot Home.
`is_new_construction`	boolean · nullable	True for new construction.
`has_virtual_tour`	boolean	True when the listing has a 3D, video or virtual tour.

Integration

One POST, typed rows

Base URL https://api.quanticdata.io/v1, Bearer auth, the same key as every other Data API. Endpoint: POST /v1/scraper/collectors/redfin_search/run.

curl -X POST https://api.quanticdata.io/v1/scraper/collectors/redfin_search/run \
  -H "Authorization: Bearer $QD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"location":"78701","max_results":100}'

import requests

r = requests.post(
    "https://api.quanticdata.io/v1/scraper/collectors/redfin_search/run",
    headers={"Authorization": f"Bearer {QD_API_KEY}"},
    json={
        "location": "78701",
        "max_results": 100
    },
    timeout=120,
)
for row in r.json()["payload"]["results"]:
    print(row)

const res = await fetch(
  "https://api.quanticdata.io/v1/scraper/collectors/redfin_search/run",
  {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.QD_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"location":"78701","max_results":100}),
  },
);
const { payload } = await res.json();
console.table(payload.results);

claude mcp add quanticdata \
  -e QUANTICDATA_API_KEY=qd_live_your_key_here \
  -- npx -y quanticdata-mcp

# then, in the chat:
> run the redfin_search collector with location="78701" and max_results=100

Example response

POST /v1/scraper/collectors/redfin_search/run

$ curl $QD/redfin_search/run \
    -H "Authorization: Bearer $QD_API_KEY" \
    -d '{"location": "78701", "max_results": 100}'
{ "status": "done", "count": 100,
  "results": [
    {
      "mls_id": "…",
      "address": "…",
      "street": "…",
      "city": "…" } ],
  "cost": 0.08 }
# 100 listings × $0.0008 · nothing delivered, nothing charged

Try it

Redfin listings, running now

Change the input and run it against the live collector — nothing to install, no sign-up.

Run it from your own code, on your own inputs

Same collector, same rows — $2 of free API credit every month, no card.

Get my free API key

Redfin Scraper API: from location, QuanticData reads the Redfin results and returns one row per listing with address, street and city, at $0.0008 per delivered listing. — You send location and country; the run goes out through a residential exit and comes back as listings with rank, mls_id and address — 42 fields on every row — and you are billed $0.0008 for each listing actually delivered, nothing for a run that delivers none.

$0.0008 / listing2,500 listings on the free $2 every month

Semantic inputlocation, country, max_results — no URL lists

Up to 350listings per run, pagination handled for you

No browserread over HTTP/TLS — cheaper and faster than rendering

Pricing

Redfin Scraper API pricing

$0.0008 per delivered listing. A run that delivers nothing costs nothing: blocked pages, challenges and retries are on us, and the $2 monthly allowance covers about 2,500 listings before you spend anything.

$0.0008per delivered listing$0.8 per 1,000 delivered listings

2,500 listingson the free allowance$2 every month, no card

Zero rowszero chargeblocks, captchas and retries are on us

−30%on volume tiersthe catalog returns your key's price

Pay as you go

$0/mo

$2 free credit / month
60 requests / min
List unit prices

Starter

$19/mo

$15 free credit / month
300 requests / min
10% off unit prices

Growth

$79/mo

$50 free credit / month
600 requests / min
20% off unit prices

Scale

$299/mo

$250 free credit / month
1,200 requests / min
30% off unit prices

Same wallet, same key and same $2 monthly allowance as every other Data API. Prices are launch pricing read live from the billing config — GET /v1/scraper/collectors returns the price your key actually pays.

What people build with the Redfin scraper API

Three shapes of work this endpoint was designed around.

ZIP-level market snapshots

Every active listing in a ZIP with price, beds, baths and sqft in one run — price per square foot by ZIP without a crawler.

Cross-portal matching

MLS id and split address on each row, so Redfin listings join cleanly to the Zillow collectors on the same homes.

Inventory monitoring

Re-run a ZIP weekly and diff by mls_id: new listings, price cuts and homes gone pending, from price and status.

Redfin Scraper API versus rolling your own

The differences that actually cost time when you build this in-house.

	DIY scraper	This collector
Fetches per ZIP	Nine pages of cards	One — the embedded API reply carries the whole region
Ads	Advertisement cards in the grid	None: the JSON has no ads
Photos	Carousel images misaligned with listings	The listing’s own photo URL
Identity	Address text	MLS id, split address, coordinates

What people search for

Live autocomplete demand around Redfin listings, pulled with our own Keyword ideas collector.

Redfin Scraper API: the POST to the redfin_search collector, 100 listings delivered and the bill, 100 × $0.0008 = $0.08 in usage.cost_usd; zero listings would cost $0. — The same call you would paste into a terminal: a Bearer key, location and country in the body, and back the envelope every QuanticData endpoint returns — type, message, payload — where count is how many listings arrived and usage.cost_usd is $0.08, which is 100 × $0.0008. A run that delivers nothing costs nothing. The key is good for 60 req/min on the free tier.

Sources and standards

The platform documentation and standards this collector is built against — check any claim on this page against the primary source:

FAQ

Questions we get about the Redfin scraper API.

Something else? Ask us

Does Redfin have a public API?

No public one. The page embeds the replies to its own internal API, and that is what this collector reads — no key, no login, no browser.

Why a ZIP and not a city?

Because that is the region shape whose embedded reply carries the complete list in one response. A ZIP returns up to 350 homes in a single fetch; that is the cap on max_results.

Does it include rentals or sold homes?

It reads the for-sale search for the ZIP. status is stated per row, so pending and contingent homes are labelled rather than dropped.

How does it relate to the Zillow collectors?

Same homes, different portal: match on mls_id or the split address and compare price and status side by side.

Is there a free Redfin scraper API?

Every account gets $2 of credit every month with no card, which is about 2,500 delivered listings on this endpoint at $0.0008 each. It renews monthly, and a run that delivers nothing is never billed — so a failed or blocked attempt does not eat the allowance.

How much does one run cost?

Multiply the rows you actually receive by $0.0008. A run capped at 350 listings — the maximum for this collector — costs $0.28 if every row comes back, and less when the source has fewer. Volume tiers take up to 30% off, and GET /v1/scraper/collectors returns the price your key actually pays.

Run the Redfin scraper API now

$2 of free credit every month, no card. Your key returns its own prices from GET /v1/scraper/collectors.

Run in dashboard

Illustration: three coloured zones of the page that is read (Redfin results) turn into clean JSON with the fields address, street and city; 42 fields on every row.