/v1/properties, poll /v1/results/{job_id} until it is complete, then load the property objects into pandas. This guide has the whole script and the real output it produced.We run APIllow, so the API here is ours. The code is the client we would hand a new customer, and the output comes from a live run on 2026-10-21 with agent names and phones removed. For background, read what happened to the Zillow API and what to use instead.
What you need
- A current Python 3 with
pip install requests pandas - An API key from the signup form. The free plan covers 50 properties a month.
- The key in an environment variable:
export APILLOW_KEY=your_key
Three facts from the API docs shape the code. Requests are asynchronous: the POST returns a job_id. Usage is counted per property returned, not per call. Each request is capped by plan: 5 properties on Free, 10 on Pro, 25 on Ultra, 50 on Mega.
The client
This is the whole client: submit a job, wait for it, unwrap the results, flatten them. Save it as client.py.
import json
import os
import time
import pandas as pd
import requests
API = "https://api.apillow.co"
HEADERS = {"X-API-Key": os.environ["APILLOW_KEY"]}
PLAN_CAP = 5 # properties per request: Free 5, Pro 10, Ultra 25, Mega 50
def detail(r):
try:
return r.json().get("detail", r.text)
except ValueError:
return r.text
def submit(payload, retries=3):
for _ in range(retries):
r = requests.post(f"{API}/v1/properties", headers=HEADERS, json=payload, timeout=30)
if r.status_code == 429 and "Rate limit" in detail(r):
time.sleep(15) # per-minute limit: wait and retry
continue
if r.status_code in (400, 401, 429):
# 400 = bad input or a list over your plan cap, 401 = bad key,
# 429 = monthly quota used up
raise RuntimeError(f"{r.status_code}: {detail(r)}")
r.raise_for_status()
return r.json()["job_id"]
raise RuntimeError("still rate limited after retries")
def wait(job_id, every=10, timeout=300):
deadline = time.time() + timeout
while time.time() < deadline:
r = requests.get(f"{API}/v1/results/{job_id}", headers=HEADERS, timeout=30)
r.raise_for_status()
job = r.json()
if job["status"] == "complete":
return job
if job["status"] == "failed":
raise RuntimeError(job.get("errors"))
time.sleep(every)
raise TimeoutError(job_id)
def lookup(**payload):
job = wait(submit(payload))
props = [i["property"] for i in job["results"] if i.get("property")]
return props, job["errors"]
def lookup_many(key, items, **extra):
props, errors = [], []
for i in range(0, len(items), PLAN_CAP): # explicit lists must fit the cap
p, e = lookup(**{key: items[i:i + PLAN_CAP]}, **extra)
props += p
errors += e
return props, errors
def to_frame(props):
df = pd.json_normalize(props, sep="_")
for col in df.columns: # nested lists become JSON text so a CSV cell holds them
if df[col].map(lambda v: isinstance(v, list)).any():
df[col] = df[col].map(json.dumps)
return dfsubmit separates the failures the docs describe: a 429 whose message mentions the rate limit is a per-minute limit, so it sleeps and retries, while any other 429 means your monthly quota is used up and retrying will not help. A 400 means bad input, including an explicit list longer than your plan cap, and a 401 means a bad key. The docs list no 402, so anything else falls through to raise_for_status.
wait polls every 10 seconds because the docs recommend 10 to 15; the docs say results are typically ready in 3 to 10 seconds, and a webhook beats polling if you submit many jobs. lookup_many splits an explicit list into plan-sized requests. Billing is per property, so splitting costs nothing extra.
Search a ZIP code
ZIP codes go in as integers, so 02116 is sent as 2116. The type filter takes all, sale, rent, sold or fsbo, and max_items is a ceiling that is lowered to your plan's limit.
from client import lookup, to_frame
props, errors = lookup(zipcodes=[90210], type="sale", max_items=10)
df = to_frame(props)
cols = ["zpid", "street_address", "price", "zestimate", "bedrooms",
"bathrooms", "living_area", "home_status", "days_on_zillow"]
print(df[cols].head(5).to_string(index=False))
df.to_csv("properties.csv", index=False)
print(len(df), "rows,", len(df.columns), "columns,", len(errors), "errors")That printed this on 2026-10-21 for ZIP 90210 (NaN marks a null field):
zpid street_address price zestimate bedrooms bathrooms living_area home_status days_on_zillow 20533547 73 Beverly Park Ln 69995000 60102700.0 9 22.0 28500 FOR_SALE 120.0 20523735 1420 Davies Dr 69995000 NaN 8 14.0 21800 FOR_SALE 161.0 89145209 1407 Davies Dr 67500000 NaN 8 13.0 16079 FOR_SALE 19.0 20532066 2571 Wallingford Dr 49995000 NaN 12 24.0 38000 FOR_SALE 169.0 20523172 1454 Blueridge Dr 3995000 3793100.0 4 4.0 3274 FOR_SALE NaN 10 rows, 43 columns, 0 errors
Three of those five rows have no Zestimate, and one has no days_on_zillow. Code that assumes every field is present will fail on real data, so the frame keeps nulls as nulls.
What the raw response looks like
Behind the DataFrame is this JSON: the second row above, trimmed, with the agent block redacted and price history cut to two events:
{
"job_id": "6fe0ea70-d152-4eb1-bef0-6cac569c9a65",
"status": "complete",
"results": [{
"url": "https://www.zillow.com/homedetails/1420-Davies-Dr-Beverly-Hills-CA-90210/20523735_zpid/",
"success": true,
"zpid": 20523735,
"elapsed_seconds": 4.337,
"property": {
"street_address": "1420 Davies Dr",
"city": "Beverly Hills", "state": "CA", "zipcode": "90210",
"price": 69995000,
"last_sold_price": 800000,
"last_sold_date": "1998-02-24",
"zestimate": null,
"rent_zestimate": null,
"bedrooms": 8, "bathrooms": 14.0, "living_area": 21800,
"lot_size": 248200.0,
"year_built": null,
"home_status": "FOR_SALE",
"price_history": [
{"date": "2026-05-13", "event": "Listed for sale", "price": 69995000, "source": "CLAW"},
{"date": "2026-04-16", "event": "Listing removed", "price": 69995000, "source": "CLAW"}
],
"listing_agent": {"name": "[REDACTED]", "phone": "[REDACTED]", "email": null,
"company": "Christie's International Real Estate SoCal"},
"days_on_zillow": 161
}
}],
"errors": []
}Each item in results carries success, the zpid and the property object; failed lookups land in errors, so check that list. For a recently sold home in the same ZIP, the same fields were:
"price": 4116000, "last_sold_price": 4116000, "last_sold_date": "2026-10-06", "zestimate": 4115800, "year_built": 1931, "home_status": "RECENTLY_SOLD", "days_on_zillow": 16
Which fields to trust
We measured field presence on 100 results from the for-sale filter and 100 from the sold filter across 10 ZIP codes. The full table is in the coverage section of our Zillow API guide. For Python code:
zestimate: 46% on for-sale results, 95% on the sold filter. See the Zestimate API guide for handling the gap.year_built: 15% for sale, 89% sold. Do notint()it blindly.last_sold_date: 85% for sale, 99% sold. The sold data guide covers comps and sale dates.price_history: 97% and 99% had at least one event.
Look up specific addresses or ZPIDs
For a list you already have, use lookup_many. The key is addresses for street addresses, zpids for Zillow property IDs, or urls for listing URLs:
from client import lookup_many, to_frame
addresses = ["123 Main St, Cleveland, OH 44101", "456 Oak Ave, Lakewood, OH 44107"]
props, errors = lookup_many("addresses", addresses)
for e in errors:
print(e["url"], e["error"]) # lookups that found nothing
df = to_frame(props)Per the docs, a call that returns nothing is not counted against your quota. For messy address lists, the ZPID lookup guide covers resolving them at scale.
Export to CSV
The script above already wrote properties.csv with 43 columns: json_normalize flattened the agent object into listing_agent_* columns, and to_frame stored nested lists (price_history, comps, image_urls) as JSON text, one cell each. To skip pandas, ask the server for a flat file once the job is complete:
curl "https://api.apillow.co/v1/results/YOUR_JOB_ID?format=csv" \\ -H "X-API-Key: $APILLOW_KEY" -o results.csv
For spreadsheets, see the Excel and CSV export guide.
What we have not tested here
The output above is from a live run. The client itself was exercised against that run's saved responses with the network calls replaced (poll loop, 429 branches, chunking), not against the live API with a fresh key. Try it with a small max_items first.
Frequently asked questions
How do I get Zillow data in Python?
Zillow has no self-serve API, so use a third-party API that returns Zillow data as JSON. With APIllow you POST to /v1/properties with the requests library, poll /v1/results/{job_id} until the status is complete, and load the property objects into pandas.
Is there a Zillow Python library?
We know of no official one. Wrappers written for Zillow's retired public API stopped working when it was retired in 2021. You do not need an SDK for APIllow; requests and pandas are enough.
How do I export Zillow data to CSV in Python?
Flatten the property objects with pandas.json_normalize, convert nested lists to JSON text, and call DataFrame.to_csv. Alternatively request /v1/results/{job_id}?format=csv once the job is complete and the server returns a flat file.
How do I look up a Zillow property by address in Python?
POST {"addresses": ["123 Main St, City, ST 12345"]} to /v1/properties with your X-API-Key header, then poll the returned job_id. The result includes the zpid and the full property record. The cap on addresses per request depends on your plan.
Run it on your own ZIP code
Get a Free API KeyMore: the full API documentation, the Zillow API alternatives guide, and the MCP server for AI agents.