Zillow scraper API

Real estate · v1.1.0 · zillow_search

$0.001 / listing

$1.00 / 1K · pay per delivered listing

A Zillow scraper API that turns a US location into property rows: price, beds, baths, living area, lot size, home type, listing status, Zestimate and rent Zestimate, days on Zillow, broker, coordinates, photo and the listing URL. For sale, for rent or recently sold.

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

Run in dashboard See the request

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

What it does

What a Zillow scraper API does

Real-estate analysis needs the whole board, not one listing at a time: everything for sale in a ZIP, with size, price and location on the same row. This collector paginates a Zillow search and returns exactly that, with the address already split into street, city, state and ZIP.

Zillow ships its results inside the page's data payload — but not always in the same shape: sometimes the search state is a sub-object, sometimes a JSON string nested inside the props tree. Both forms have been seen on the same day, so the parser handles both instead of breaking on whichever one it did not expect.

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	City and state, ZIP or neighborhood, e.g. "Austin, TX".
`status`	string	no	Which listings to collect. One of: `for_sale`, `for_rent`, `sold`.
`max_results`	integer	no	How many listings to deliver at most (1–500). You pay only for delivered listings.

Outputs — 53 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 across pages.
`page`	integer	Results page the row came from.
`zpid`	string	Zillow property id. Apartment buildings are keyed by map point, and that key is delivered here.
`address`	string · nullable	Full address as shown.
`street`	string · nullable	Street line.
`city`	string · nullable	City.
`state`	string · nullable	State code.
`zipcode`	string · nullable	ZIP code.
`price`	string · nullable	Price as shown.
`price_value`	number · nullable	Numeric price.
`currency`	string · nullable	Currency symbol.
`beds`	number · nullable	Bedrooms.
`baths`	number · nullable	Bathrooms.
`area_sqft`	number · nullable	Living area in sqft.
`lot_size`	number · nullable	Lot size when published.
`home_type`	string · nullable	SINGLE_FAMILY, CONDO, TOWNHOUSE…
`status`	string · nullable	Status text (Active, Pending…).
`status_type`	string · nullable	FOR_SALE / FOR_RENT / SOLD.
`listing_type`	string · nullable	For Sale by Agent/Owner, Foreclosure…
`zestimate`	number · nullable	Zillow price estimate.
`rent_zestimate`	number · nullable	Zillow rent estimate.
`days_on_zillow`	number · nullable	Days listed.
`broker`	string · nullable	Listing brokerage.
`latitude`	number · nullable	GPS latitude.
`longitude`	number · nullable	GPS longitude.
`image`	string · nullable	Photo URL.
`url`	string	Listing URL.
`lot_size_unit`	string · nullable	Unit of `lot_size` as Zillow states it: "sqft" or "acres".
`lot_size_sqft`	number · nullable	Lot size converted to square feet, whichever unit Zillow used.
`unit`	string · nullable	Unit or apartment number when the listing has one.
`currency_code`	string · nullable	ISO currency code (USD).
`tax_assessed_value`	number · nullable	Tax assessed value.
`price_change`	number · nullable	Latest price change in currency units; negative on a price cut.
`price_change_date`	string · nullable	Date of that price change (YYYY-MM-DD).
`open_house`	string · nullable	Open house line as shown on the card.
`open_house_start`	string · nullable	Open house start (local time, ISO 8601).
`open_house_end`	string · nullable	Open house end (local time, ISO 8601).
`coming_soon_date`	string · nullable	On-market date of a Coming Soon listing (YYYY-MM-DD).
`builder`	string · nullable	Builder name on new construction.
`is_new_construction`	boolean	True for new construction.
`is_showcase`	boolean	True for a Zillow Showcase listing.
`has_3d_tour`	boolean	True when the listing has a 3D tour.
`has_video`	boolean	True when the listing has a video.
`photo_count`	integer · nullable	Photos in the listing card carousel.
`photos`	string[]	Up to six photo URLs.
`date_sold`	string · nullable	Sale date on sold listings (YYYY-MM-DD).
`is_building`	boolean	True when the row is an apartment building with several floor plans (rental searches).
`building_name`	string · nullable	Building or community name.
`units`	object[] · nullable	Floor plans of a building: beds, price as shown ("$2,110+"), price_value. `price` and `price_value` on the row are the lowest of these.
`available_units`	integer · nullable	Units currently available in the building.
`min_rent`	number · nullable	Lowest base rent in the building.
`max_rent`	number · nullable	Highest base rent in the building.
`leasing_phone`	string · nullable	Leasing office phone shown on the card.

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/zillow_search/run.

curl -X POST https://api.quanticdata.io/v1/scraper/collectors/zillow_search/run \
  -H "Authorization: Bearer $QD_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"location":"Austin, TX","status":"for_sale","max_results":80}'

import requests

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

const res = await fetch(
  "https://api.quanticdata.io/v1/scraper/collectors/zillow_search/run",
  {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.QD_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({"location":"Austin, TX","status":"for_sale","max_results":80}),
  },
);
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 zillow_search collector with location="Austin, TX" and status="for_sale"

Example response

POST /v1/scraper/collectors/zillow_search/run

$ curl $QD/zillow_search/run \
    -H "Authorization: Bearer $QD_API_KEY" \
    -d '{"location": "Austin,  TX", "status": "for_sale", "max_results": 80}'
{ "status": "done", "count": 80,
  "results": [
    {
      "zpid": "…",
      "address": "…",
      "street": "…",
      "city": "…" } ],
  "cost": 0.08 }
# 80 listings × $0.001 · nothing delivered, nothing charged

Try it

Zillow search, 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

Zillow scraper API: from location, QuanticData reads the Zillow results and returns one row per listing with building_name, zpid and address, at $0.001 per delivered listing. — You send location and status; the run goes out through a residential exit and comes back as listings with rank, page and zpid — 53 fields on every row — and you are billed $0.001 for each listing actually delivered, nothing for a run that delivers none.

$0.001 / listing2,000 listings on the free $2 every month

Semantic inputlocation, status, max_results — no URL lists

Up to 500listings per run, pagination handled for you

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

Pricing

Zillow scraper API pricing

$0.001 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,000 listings before you spend anything.

$0.001per delivered listing$1 per 1,000 delivered listings

2,000 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 Zillow scraper API

Three shapes of work this endpoint was designed around.

Market analysis

Price per square foot by neighbourhood, computed from rows rather than eyeballed.

Investment screening

Filter for rent Zestimate against asking price across a whole city.

Comparables

Pull recently sold properties around an address to build a comp set.

Zillow scraper API versus rolling your own

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

	DIY scraper	This collector
Coverage	One listing per request	A whole search, paginated
Address	One string to parse yourself	Street, city, state and ZIP split
Payload shape	Breaks when Zillow changes it	Both known shapes handled

What people search for

Live autocomplete demand around Zillow search, pulled with our own Keyword ideas collector.

A closed API and a licensed alternative

Zillow's public API programme has been progressively closed — the GetSearchResults and Zestimate endpoints that powered a generation of side projects are gone, and what remains is partner-oriented. There is no self-serve API returning search results.

The licensed alternative is MLS data, and it is genuinely better where it applies: authoritative, contractually clean, with agent-level fields Zillow never shows. It also requires being a licensed real-estate professional or partnering with one, agreements with hundreds of regional MLSs and a RESO integration. For research, screening and market analysis rather than a brokerage product, public listing data is what is realistically available.

Limits, coverage and the legal bit

Up to 500 listings per run — the deepest cap in the catalogue, because market analysis needs whole markets rather than samples, and a bigger cap also means fewer requests. US only. Addresses arrive pre-split into street, city, state and ZIP, so joins do not depend on an address parser. Throughput is your plan's rate limit rather than anything about the collector: 60 requests/minute on pay-as-you-go, up to 1,200 on the top tier.

Treat both Zestimates as one model's opinion rather than as market truth. Their value in a dataset is as a screening signal — the spread against asking price — not as a valuation.

This is the collector to be most careful with. Collecting publicly visible data is generally lawful in most jurisdictions, and courts have repeatedly declined to treat reading a public page as unauthorised access. Zillow's terms nonetheless explicitly prohibit automated collection and it has historically been willing to enforce them; listing photos and descriptions are copyrighted by the brokerage, and agent names are personal data. Get real advice before building a commercial product on it. None of this is legal advice — get some for your actual use case.

Zillow scraper API: the POST to the zillow_search collector, 80 listings delivered and the bill, 80 × $0.001 = $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 status 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 80 × $0.001. 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 Zillow scraper API.

Something else? Ask us

Can I collect rentals and sold properties?

Yes — status accepts for_sale, for_rent and sold. Rentals return apartment buildings with their floor plans and a starting price.

What counts as a location?

What Zillow accepts: a city and state ("Austin, TX"), a ZIP code, or a neighbourhood name.

Is the Zestimate included?

When Zillow publishes it for the listing, yes, along with the rent Zestimate. Both are Zillow's own estimates, not ours.

Is there a free Zillow scraper API?

Every account gets $2 of credit every month with no card, which is about 2,000 delivered listings on this endpoint at $0.001 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.001. A run capped at 500 listings — the maximum for this collector — costs $0.5 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.

Can I get sold prices as well as asking prices?

Yes — set status to recently sold. It is the status people forget and usually the most valuable, because it records what buyers actually paid rather than what sellers hoped for.

Why is the run cap so high?

Because real-estate questions are about markets, not samples. Five hundred listings per run means a small market fits in one call, which keeps request counts and rate-limit pressure low for a nightly sweep.

Run the Zillow 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 (Zillow results) turn into clean JSON with the fields building_name, zpid and address; 53 fields on every row.