Zillow tracks over 110 million U.S. properties. For real estate investors, proptech builders, and market researchers, that dataset is irreplaceable. The problem: Zillow's official API was deprecated for most use cases years ago, and Zillow's anti-bot infrastructure is now one of the more aggressive in the consumer web.
This article covers what you're actually up against, benchmarks real scraping APIs against Zillow, and walks through a working Python implementation. Benchmark data sourced from ScrapeOps, which independently tests scraping providers against real websites under controlled conditions.
The End of Zillow's Official API
Zillow launched its public API in the mid-2000s. For years, developers could query property data, Zestimates, and listing details through structured endpoints with an API key. That era ended gradually but decisively — Zillow shut down new API registrations, deprecated key endpoints, and limited surviving access to a narrow set of partners through their Bridge Interactive platform.
What remains in 2026 is effectively closed to most developers:
- Bridge Interactive API: Reserved for MLS members and licensed brokers. Individual developers and proptech startups rarely qualify.
- Zestimate API: No longer publicly available. Zillow surfaces Zestimates only through their own products.
- Listing data: Available to Zillow Premier Agent partners as part of lead generation arrangements, not as a general data API.
The practical result: if you need Zillow property data at any meaningful scale, scraping is the only option — and Zillow knows it.
What Makes Zillow Hard to Scrape
Zillow's difficulty score in the ScrapeOps benchmark suite is high enough to put it in the "hard" tier alongside LinkedIn and Google. Here's specifically what you're up against.
1. Incapsula/Imperva WAF
Zillow runs Imperva (formerly Incapsula) as its primary web application firewall. Imperva is one of the most sophisticated commercial bot detection products available. It operates at multiple layers simultaneously: network-level traffic analysis, TLS fingerprinting, HTTP header profiling, and JavaScript-based browser fingerprinting via its client-side sensor.
When Imperva's sensor loads in the browser, it collects dozens of signals — canvas fingerprint, WebGL renderer string, audio context behavior, installed fonts, screen dimensions, hardware concurrency. Headless browsers leak on several of these by default. An unpatched Puppeteer or Playwright instance gets flagged within two or three requests.
2. JavaScript Fingerprinting
Even apart from Imperva, Zillow's React frontend runs fingerprinting logic that checks for headless browser tells: navigator.webdriver being true, missing browser plugins, anomalous window.chrome properties, and inconsistencies between reported user agent and actual JavaScript engine behavior. The checks run on every page load and feed a risk score that determines whether you see real content or a challenge page.
3. Dynamic React Rendering
Zillow's property search and listing pages are React single-page applications. The listing data you actually want — prices, addresses, square footage, Zestimate — is injected into the DOM after JavaScript execution. A naive requests + BeautifulSoup approach returns HTML with empty shells where content should be. You need either a full headless browser or a scraping API that renders JavaScript server-side before returning the response.
Some listing data is embedded in a __NEXT_DATA__ script tag in the initial HTML, but this is inconsistent across page types and changes with Zillow's build deployments.
4. IP Reputation and Rate Limiting
Zillow maintains blocklists for known datacenter IP ranges. AWS, GCP, DigitalOcean, and Hetzner IP blocks are identified quickly. Even residential proxy IPs get rate-limited once they generate suspicious traffic patterns — too many requests, too regular timing, too consistent user agents.
The safe organic request rate for a single residential IP is approximately one request every 3-8 seconds for sustained scraping. Burst faster than that and you trigger Imperva's rate-limiting rules.
5. Legal Considerations: CFAA and ToS
Zillow's Terms of Use explicitly prohibit automated scraping, crawling, or data extraction. This creates legal exposure under two frameworks:
CFAA (Computer Fraud and Abuse Act): The 2022 Supreme Court ruling in Van Buren v. United States narrowed CFAA's scope, and the Ninth Circuit's hiQ v. LinkedIn decision confirmed that scraping publicly accessible data generally does not constitute unauthorized computer access. However, if Zillow actively blocks your scraper and you implement workarounds to circumvent those blocks, the legal picture becomes less clear.
ToS breach: Violating terms of service is a civil matter, not criminal — but it can result in account termination and cease-and-desist letters, especially for commercial-scale operations.
The practical guidance: scrape publicly visible listing data, don't scrape behind login, don't overload their infrastructure, and if you're building a commercial product on Zillow data, consult a lawyer.
Approaches Compared
Before the benchmark table, here's a qualitative view of the four main approaches.
Direct HTTP requests with residential proxies: Workable for small scale, fragile at medium scale. Imperva's JavaScript challenges stop pure HTTP clients cold. You need to handle __NEXT_DATA__ parsing carefully and rotate proxies aggressively. Maintenance burden is high as Zillow updates detection.
Browser automation (Playwright/Puppeteer): More capable than raw HTTP, but headless browser detection is a real problem. You need stealth patches (playwright-extra with stealth plugin, or undetected-chromedriver) plus residential proxies. Works at low volume; at high volume, managing a browser fleet gets expensive and operationally complex.
Dedicated Zillow scrapers (e.g., Apify actors): Pre-built scrapers that handle Zillow specifically. Convenient, but you're dependent on the maintainer keeping up with Zillow's changes — and Zillow changes frequently. Cost and rate limits vary.
Scraping APIs (ScraperAPI, Scrape.do, ScrapeOps): Managed services that handle proxy rotation, fingerprint spoofing, and JavaScript rendering. You send a URL, you get back the rendered HTML. This is the most reliable approach for sustained Zillow data collection.
Benchmark Results: Scraping APIs on Zillow
The following data is drawn from the ScrapeOps benchmark suite, measuring real success rates, average latency, and cost per 1,000 successful requests against Zillow property and search pages. Check the source for current numbers — these are updated as providers and Zillow's defenses evolve.
| Provider | Success Rate | Avg Latency | Cost per 1K Successful Req |
|---|---|---|---|
| ScraperAPI | ~98% | ~6.1s | ~$810 |
| Scrapfly | ~96% | ~18.2s | ~$850 |
| Scrape.do | ~89% | ~6.4s | ~$310 |
| Scrapingant | ~84% | ~13.1s | ~$210 |
| ZenRows | ~71% | ~5.9s | ~$340 |
| Zyte API | ~68% | ~11.3s | ~$250 |
| Scrapingdog | ~61% | ~19.4s | ~$220 |
Reading the numbers:
Zillow is harder than Amazon. The spread between top and bottom performers is wider — 37 percentage points between ScraperAPI and Scrapingdog. At 61% success, you're paying for almost half your requests to fail. That makes nominal "cheap" providers actually more expensive when you account for the retries you'll need and the data gaps you'll produce.
Latency on Zillow is higher across the board compared to simpler sites. The JavaScript rendering requirement adds 2-5 seconds regardless of provider, and Imperva's challenge resolution adds more. Scrapfly's 18.2s average is notable — high success rate, but if you're processing thousands of property pages, that throughput cost is real.
Scrape.do emerges as the value play: 89% success at 6.4s average latency and $310 per 1K successful requests. For teams that don't need the top-tier success rate but want a reasonable cost/reliability balance, it's the practical choice.
Source: ScrapeOps Benchmark Suite
Python Implementation: Scraping Zillow Property Pages
Here's a production-ready pattern using ScraperAPI to pull Zillow property listing data. The approach targets the __NEXT_DATA__ JSON block embedded in Zillow's HTML, which contains structured listing data without additional parsing complexity.
import requests
import json
import time
import logging
from typing import Optional
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
logger = logging.getLogger(__name__)
SCRAPERAPI_KEY = "your_api_key_here"
SCRAPERAPI_URL = "http://api.scraperapi.com"
def scrape_zillow_property(zpid: str) -> Optional[dict]:
"""
Scrape a Zillow property page by ZPID (Zillow Property ID).
Returns structured listing data or None on failure.
"""
target_url = f"https://www.zillow.com/homedetails/{zpid}_zpid/"
params = {
"api_key": SCRAPERAPI_KEY,
"url": target_url,
"render": "true", # JavaScript rendering required for Zillow
"premium": "true", # Residential IP pool — essential for Imperva bypass
"country_code": "us", # Pin to US geo for consistent results
"device_type": "desktop",
}
try:
response = requests.get(SCRAPERAPI_URL, params=params, timeout=90)
response.raise_for_status()
except requests.exceptions.Timeout:
logger.warning(f"Timeout scraping ZPID {zpid}")
return None
except requests.exceptions.RequestException as e:
logger.error(f"Request error for ZPID {zpid}: {e}")
return None
# Zillow embeds full listing data in the __NEXT_DATA__ script block
from bs4 import BeautifulSoup
soup = BeautifulSoup(response.text, "html.parser")
next_data_tag = soup.find("script", {"id": "__NEXT_DATA__"})
if not next_data_tag:
logger.warning(f"No __NEXT_DATA__ found for ZPID {zpid} — possible block or page change")
return None
try:
page_data = json.loads(next_data_tag.string)
except json.JSONDecodeError as e:
logger.error(f"JSON parse error for ZPID {zpid}: {e}")
return None
# Navigate the Next.js data structure to property details
try:
props = page_data["props"]["pageProps"]
home_data = props.get("componentProps", {}).get("gdpClientCache", {})
# gdpClientCache is a dict keyed by ZPID — grab the first (only) entry
if home_data:
listing_key = next(iter(home_data))
home = home_data[listing_key].get("property", {})
else:
# Fallback: some page variants use a different structure
home = props.get("initialData", {}).get("building", {})
except (KeyError, StopIteration) as e:
logger.warning(f"Unexpected page structure for ZPID {zpid}: {e}")
return None
return {
"zpid": zpid,
"address": home.get("address", {}).get("streetAddress"),
"city": home.get("address", {}).get("city"),
"state": home.get("address", {}).get("state"),
"zip_code": home.get("address", {}).get("zipcode"),
"price": home.get("price"),
"zestimate": home.get("zestimate"),
"rent_zestimate": home.get("rentZestimate"),
"bedrooms": home.get("bedrooms"),
"bathrooms": home.get("bathrooms"),
"living_area": home.get("livingArea"),
"lot_size": home.get("lotSize"),
"year_built": home.get("yearBuilt"),
"home_type": home.get("homeType"),
"listing_status": home.get("homeStatus"),
"days_on_zillow": home.get("daysOnZillow"),
"url": target_url,
}
def scrape_zillow_search(location: str, max_pages: int = 5) -> list:
"""
Scrape Zillow search results for a given location string.
Returns list of listing summary dicts.
"""
results = []
for page in range(1, max_pages + 1):
if page == 1:
target_url = f"https://www.zillow.com/homes/{location.replace(' ', '-')}_rb/"
else:
target_url = f"https://www.zillow.com/homes/{location.replace(' ', '-')}/{page}_p/"
logger.info(f"Scraping page {page}: {target_url}")
params = {
"api_key": SCRAPERAPI_KEY,
"url": target_url,
"render": "true",
"premium": "true",
"country_code": "us",
}
try:
response = requests.get(SCRAPERAPI_URL, params=params, timeout=90)
response.raise_for_status()
except requests.exceptions.RequestException as e:
logger.error(f"Page {page} failed: {e}")
break
from bs4 import BeautifulSoup
soup = BeautifulSoup(response.text, "html.parser")
next_data_tag = soup.find("script", {"id": "__NEXT_DATA__"})
if not next_data_tag:
logger.warning(f"No data on page {page} — stopping pagination")
break
try:
page_data = json.loads(next_data_tag.string)
search_state = (
page_data["props"]["pageProps"]
.get("searchPageState", {})
.get("cat1", {})
.get("searchResults", {})
.get("listResults", [])
)
results.extend(search_state)
logger.info(f"Page {page}: {len(search_state)} listings found")
except (KeyError, json.JSONDecodeError) as e:
logger.warning(f"Parse error on page {page}: {e}")
break
# Rate limit between pages — even via API
time.sleep(2.0)
return results
if __name__ == "__main__":
# Example: search Austin TX listings
listings = scrape_zillow_search("Austin TX", max_pages=3)
print(f"\nTotal listings collected: {len(listings)}")
for listing in listings[:5]:
address = listing.get("address", "N/A")
price = listing.get("price", "N/A")
beds = listing.get("beds", "?")
baths = listing.get("baths", "?")
sqft = listing.get("area", "?")
status = listing.get("statusText", "?")
print(f" {address} | {price} | {beds}bd/{baths}ba | {sqft}sqft | {status}")
Key implementation notes:
-
render: trueis non-negotiable for Zillow. Without JavaScript execution, you get empty shells. -
premium: trueroutes through residential IPs. Datacenter IPs are blocked by Imperva almost immediately on Zillow. - The 90-second timeout accounts for JavaScript render time plus Imperva challenge resolution. Default timeouts will produce false failures.
- The
__NEXT_DATA__structure changes with Zillow's Next.js builds. The nested path shown here is current as of early 2026 but should be validated when you first deploy. - The 2-second inter-page delay is conservative but worth it — even proxied requests can trigger rate limiting if your job runs too aggressively.
Zillow's API Changes: Why Scraping Became Necessary
The trajectory from Zillow's early API openness to today's closed ecosystem reflects a strategic shift that played out over roughly a decade.
In the early 2010s, Zillow actively courted developers. Their API enabled Zestimate lookups, property detail queries, and market data pulls. The goal was distribution — more third-party apps using Zillow data meant more brand presence and more data feedback loops. Developer integrations were a growth lever.
That calculus changed as Zillow pivoted to becoming a transaction platform rather than a data aggregator. Zillow's iBuying experiment (Zillow Offers, shuttered in 2021) and its current focus on mortgage origination and Premier Agent lead generation made proprietary data a competitive asset rather than a distribution tool. Sharing Zestimates and listing data freely through an API started looking like giving away margin.
The API deprecation rollout was gradual. Key endpoints got rate-limited, then restricted to approved partners, then disabled entirely. By 2024, the public Zillow API was effectively dead for most use cases.
The practical result for the developer ecosystem: scraping moved from a workaround to the primary access method. Proptech startups, real estate analytics companies, and individual investors are all scraping Zillow in 2026 because there is no sanctioned alternative.
Choosing the Right Tool
High-volume production pipeline (50K+ requests/month): Success rate is your primary metric. At scale, a 10% failure rate means 5,000 missed data points per 50K requests — holes in your dataset that can distort analysis. ScraperAPI or Scrapfly at the premium tier.
Research and prototyping (under 10K requests): Scrape.do's balance of 89% success, fast latency, and low cost-per-request makes it well-suited for periodic jobs where you can afford some gaps.
Speed-critical applications: ScraperAPI's 6.1s average latency versus Scrapfly's 18.2s is significant if you're processing a large backfill or need near-real-time data. At 18s per request, a single thread handles roughly 3 pages per minute. At 6s, you get roughly 10.
Budget-constrained builds: Scrapingant at ~$210/1K successful requests is the lowest cost in the benchmark set that still clears 80% success. For non-critical data collection, the gap between 84% and 98% may not justify a 4x cost difference.
Get Started
-
ScraperAPI — Use code
SCRAPE13833889for 50% off your first month. Best-in-class success rate for Zillow's Imperva-protected pages. - Scrape.do — Fast response times and competitive pricing. Solid choice for mid-volume Zillow scraping without the premium cost.
- ScrapeOps — The benchmark source. Also works as a proxy aggregator and scraper health monitoring platform, useful for tracking your own success rates in production rather than guessing.
Want the full breakdown — including code for Google Maps, LinkedIn, Amazon, and Reddit scraping, plus a proxy selection guide, cost calculator, and anti-detection checklist? Get the full guide: The Complete Web Scraping Playbook 2026 — 48 pages, $9.
Top comments (0)