Zillow API Python Tutorial: Code and Real Output

April 2, 2026 · Updated October 22, 2026 · 10 min read
Quick answer: Zillow has no self-serve API, so you call a third-party one. The pattern is three steps: POST to /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

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 df

submit 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:

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 Key

More: the full API documentation, the Zillow API alternatives guide, and the MCP server for AI agents.