Zillow Sold Data API: Sale Dates & Price History

August 19, 2026 · Updated October 22, 2026 · 11 min read
Quick answer: Sold and off-market homes carry Zillow's richest data: last-sold price and date, the full price-history timeline, and Zestimates. APIllow returns those fields as JSON — look up properties by address, ZPID, or ZIP via POST /v1/properties — on every plan, including the free 50-property/month tier.

Sold data is where property analysis actually starts. Comps for a CMA, ARV for a flip, collateral checks for a lender, assessment appeals, portfolio marks — every one of them begins with the same three questions: what did this home last sell for, when, and what happened to its price along the way?

Zillow has the most complete consumer-facing answer to those questions. It also has no public API to ask them with — and here is the part that catches almost everyone who tries to scrape it: on off-market homes, the sale date is missing from the page data most scrapers read. This guide covers what sold data you can get programmatically, how to get it in one API call, and the gotchas that separate a working comps pipeline from a broken one.

What sold data can you actually get?

For any US property — by street address, ZPID, or Zillow URL — APIllow returns the full sales record alongside 50+ other fields:

Field What it is Example
last_sold_price Most recent sale price 4116000
last_sold_date Most recent sale date (ISO) "2026-10-06"
price_history Every listing, price change, pending, and sale event date, event, price, source
tax_assessed_value County assessed value (the tax_history array is not populated; see the coverage table) a single number
zestimate Zillow's valuation; present on 95% of sold-filter records, 46% of for-sale-filter records in our sample 4115800

The Zestimate row needs a caveat, which the sample below makes concrete: sold records carry it far more often than active listings, but not always. The quirk is covered in our Zestimate API guide.

One request, full sales history

# Sold homes in a ZIP code curl -X POST https://api.apillow.co/v1/properties \ -H "x-api-key: YOUR_KEY" \ -H "Content-Type: application/json" \ -d '{"zipcodes": [90210], "type": "sold", "max_items": 10}'

Poll GET /v1/results/{job_id} and each item's property object carries the sales record. This one is a real record from our 2026-10-21 sample (a Beverly Hills multi-family building), trimmed to the sale and price-history fields; the address, agent details and description are left out, and the history is cut to 3 of its 11 entries:

{ "zpid": 2075581580, "zipcode": "90210", "home_status": "RECENTLY_SOLD", "price": 4116000, "last_sold_price": 4116000, "last_sold_date": "2026-10-06", "zestimate": 4115800, "tax_assessed_value": null, "days_on_zillow": 16, "price_history": [ {"date": "2026-10-06", "event": "Sold", "price": 4116000, "source": "CLAW"}, {"date": "2026-09-17", "event": "Pending sale", "price": 4200000, "source": "CLAW"}, {"date": "2026-07-02", "event": "Listed for sale", "price": 4200000, "source": "CLAW"} ], "tax_history": [] }

Note what is in it and what is not. The sale, the pending step and the original ask are there, newest first, each with the event type and a source (here the MLS name; in other records "Public Record"). The Zestimate sits $200 under the sale price. tax_assessed_value is null and tax_history is empty on this record, which is the common case below.

Price history: what the events look like

A property's price history is its negotiation file: three cuts in ninety days says more about a seller than the listing description, and a purchase two years ago well below today's ask shows where the anchor is. Across the 200 properties in our sample (2026-10-21), the price_history arrays held 2,378 events. All 200 arrays were ordered newest first, the median length was 10.5 entries, and the oldest event was dated 1979-07-19.

EventCount in sampleWhat it signals
Listed for sale499The ask when the property hit the market; start of the days-on-market clock
Sold456The comp; pair with last_sold_date for recency filters
Price change438Ask moved while listed; the gap and cadence show seller motivation
Listing removed359De-listed without a sale; a new listing afterwards usually means the days-on-market clock reset
Pending sale186Offer accepted; ask at pending versus final price shows negotiation room
Listed for rent167Rental listing events share the same timeline
Contingent65Offer accepted with conditions outstanding

A further 208 entries had a date and price but no event label and no source, so filter on event being non-null before you branch on it. The sources are mostly MLS names, with "Public Record" on 237 entries.

Detect motivated sellers with a price-cut scan

def price_cut_signal(prop): # Dated, priced events since the most recent listing, oldest first hist = sorted((e for e in prop.get("price_history") or [] if e["date"] and e["price"]), key=lambda e: e["date"]) listing = [e for e in hist if e["event"] == "Listed for sale"] if not listing: return 0.0 since = [e for e in hist if e["date"] >= listing[-1]["date"]] first, last = since[0]["price"], since[-1]["price"] return (first - last) / first # 0.05 = 5% total cut since listing

We ran this over the 100 for-sale records in the sample: 79 had a "Listed for sale" event, and 16 of those showed a lower price now than at listing. Sort descending and the top of the list is your call sheet. The Python tutorial covers the batch-and-poll pattern it plugs into.

Why most scrapers miss the sale date

If you have ever scraped a Zillow property page and wondered why last_sold_date came back empty on an off-market home, it is not your parser. Zillow omits the sale date from the standard page payload on off-market properties — the page shows "Sold" but the machine-readable data behind it doesn't say when. The date lives in a separate internal data path that page-level scrapers never touch.

APIllow runs a dedicated enrichment step against that second data path for every off-market property. The next section shows what it recovers.

Sales history coverage: real numbers

These rates come from a sample of 200 properties, 10 ZIPs, 2026-10-21: 100 records returned by the for-sale filter and 100 by the sold filter (the sold filter returned 90 RECENTLY_SOLD and 10 FOR_SALE records), 10 per ZIP per filter. A field counts as present when it is non-null and, for lists, non-empty.

FieldFor-sale filterSold filter
last_sold_date85%99%
last_sold_price81%90%
price_history present97%99%
price_history with 6+ entries65%83%
tax_assessed_value0%79%
tax_history0%0%

Read it plainly. The sale date and the price timeline are the strong parts: last_sold_date is on 99% of sold-filter records and a six-entry-or-longer history on 83%. The sale price is thinner (90%), because a recorded sale does not always come with a price. tax_assessed_value exists only on sold-filter records. tax_history was empty on all 200 records, so do not build an assessment-appeal or tax-expense model on it; use the single tax_assessed_value where it is present and a county source for yearly history. ZIPs were chosen for spread rather than at random, so treat the rates as a guide to expect, not a guarantee.

Building comps from sold data

A comps workflow is a batch workflow: take a candidate list of nearby, similar properties, pull the sold record for each, filter to recent arm's-length sales, and compute price per square foot. The API accepts batches of properties per request (batch size scales with your plan):

import requests, time from datetime import date, timedelta API = "https://api.apillow.co/v1" HEADERS = {"x-api-key": "YOUR_KEY"} # Candidate comp addresses (county records, prior sales, your CRM...) candidates = ["1868 Bromton Dr, Lyndhurst, OH 44124", "..."] job = requests.post(f"{API}/properties", headers=HEADERS, json={"addresses": candidates}).json() # Poll for results while (r := requests.get(f"{API}/results/{job['job_id']}", headers=HEADERS).json())["status"] != "complete": time.sleep(2) props = [item["property"] for item in r["results"]] cutoff = (date.today() - timedelta(days=180)).isoformat() # sales in the last 6 months comps = [p for p in props if (p.get("last_sold_date") or "") >= cutoff and p.get("last_sold_price") and p.get("living_area")] for c in comps: print(c["street_address"], c["last_sold_price"], c["last_sold_price"] / c["living_area"])

The same flow feeds a spreadsheet instead of a script if that's where your analysis lives — the Excel/CSV export guide covers it, and the Python tutorial walks the polling pattern step by step.

Sales data by ZIP code

The API accepts ZIP-code queries with a type filter. With "type": "sold", 90 of the 100 records our sample pulled back were RECENTLY_SOLD and 10 were still FOR_SALE, so check home_status and drop what you do not want. ZIPs are sent as integers (2116 for 02116). For comps around a specific property, a candidate list of addresses is still the sharper tool; seed it from a ZIP search and pull each candidate's record individually.

Where else can you get sold data?

Source Coverage The catch
County records Authoritative, free 3,000+ counties, inconsistent formats, weeks of lag, no listing context
MLS / Bridge Interactive Deep, licensed Partner-gated, by application; terms are not public
Marketplace scraper actors Varies per actor Check whether last_sold_date is populated for off-market homes before you rely on one
APIllow Any US property, JSON Free tier of 50 properties/month; ~$0.002–$0.003 per property on paid plans

The full cost math, including how per-property pricing compares to enterprise data contracts, is in the pricing comparison. And if you landed here wondering what happened to Zillow's official API in the first place, that story is in Zillow API in 2026: status, access and alternatives

Pull your first sold record now

Free tier, no credit card. Last sold price, sale date, and full price history in one POST request.

Get API Key

Related reading

Frequently asked questions

Does Zillow have an API for sold homes?

Not a public one. Zillow retired its public API in 2021 and Bridge Interactive, the platform Zillow points partners to, is partner-gated, by application, and its terms are not public. Developers get Zillow sold data — last sold price, last sold date, and full price history — through third-party property data APIs like APIllow, which return these fields as JSON for any address, ZPID, or Zillow URL.

How do I get the last sold date for a property programmatically?

Request the property by address, ZPID, or Zillow URL and read the last_sold_date and last_sold_price fields from the JSON response. The sale date is the field most scrapers miss because Zillow omits it from the standard page payload on off-market homes; APIllow recovers it through a separate enrichment step, and it was present on 99% of sold-filter records in our 2026-10-21 sample.

Can I search recently sold homes by ZIP code?

Yes. Send a ZIP code with type set to sold. In our 2026-10-21 sample, 90 of 100 returned records were RECENTLY_SOLD and 10 were still FOR_SALE, so filter on home_status. For comps around one property, a list of candidate addresses is more precise.

How far back does Zillow price history go?

In our 2026-10-21 sample the oldest event was dated 1979 and the median history held 10.5 entries. Events include listings, price changes, pending and contingent steps, de-listings and sales, each with a date, event type, price, and source (an MLS name or Public Record).

Does the Zillow API include price history?

Not Zillow's own, which no longer exists as a public API. Through APIllow, price_history was present on 97% of for-sale-filter and 99% of sold-filter records in a 200-property sample (10 ZIPs, 2026-10-21), with six or more entries on 65% and 83%. Each entry has a date, event, price and source, newest first.

How do I get the last sold price and date?

Request the property by address, ZPID, Zillow URL or ZIP and read last_sold_price and last_sold_date. In the same sample the date was present on 85% of for-sale-filter and 99% of sold-filter records, and the price on 81% and 90%.

Final takeaway

There is no public Zillow API for sold homes, but sold data is still one API call away: last_sold_price, last_sold_date, and a price_history that reaches back years. Build around what the sample showed: the sale date and price timeline are strong, tax_history is empty, and the sold filter can return a few active listings, so filter on home_status.