I’ve built Zillow scrapers. They break every few weeks.
The page layout changes. The anti-bot system gets an update. Cloudflare rotates their challenge. Your proxy IP pool gets flagged. You wake up Monday morning to empty databases and a Slack channel full of alerts.
That’s scraping. It works until it doesn’t. And when it doesn’t, you’re the one debugging at midnight.
A REST API is the opposite experience. Same data. Structured JSON. Under 1 second per response. No proxies, no parsing, no maintenance. But it costs money. So the real question is: when does scraping make sense and when does an API make sense?
Here’s the honest comparison.
Is scraping Zillow legal?
The legal answer is messy. Scraping Zillow’s publicly visible pages is probably not a criminal act, but it definitely violates Zillow’s Terms of Use and could expose you to civil liability. Whether that matters depends on what you’re building and how risk-tolerant you are.
The 2022 Supreme Court ruling in Van Buren v. United States narrowed the CFAA’s scope. The Ninth Circuit’s hiQ v. LinkedIn decision confirmed that scraping publicly accessible data generally does not constitute unauthorized computer access under federal law.
But “not criminal” is a low bar.
Zillow’s Terms of Use explicitly prohibit automated data collection. If Zillow sends a cease-and-desist and you keep scraping, you’re in breach of contract. If you circumvent their anti-bot defenses (which they invest heavily in), that could be construed as unauthorized access under a different reading of the CFAA.
In 2025, Zillow faced eight lawsuits from competitors, regulators, and consumers on issues ranging from antitrust to copyright infringement of listing photos. They’re clearly willing to litigate.
The practical guidance: if you’re building a commercial product on Zillow data, scraping is a legal risk you don’t need to take. A licensed API removes that risk entirely.
How much does scraping Zillow actually cost?
More than most developers expect. A 2026 benchmark published on Dev.to tested 7 major proxy/scraping services against Zillow and found costs ranging from $210 to $850 per 1,000 pages.
| Scraping provider | Success rate | Avg latency | Cost per 1K pages |
|---|---|---|---|
| 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 |
Those numbers only cover the raw scraping cost. They don’t include:
- Engineering time to build and maintain the parser (Zillow uses React, so you need JavaScript rendering)
- Proxy costs if you’re not using a scraping service
- Retry costs from failed requests (only 61-98% success rates)
- Monitoring and alerting infrastructure
- Time spent debugging when the scraper breaks
Now compare that to a REST API:
| Provider | Success rate | Avg latency | Cost per 1K calls |
|---|---|---|---|
| Zillapi | 99%+ | ~1s cached | $5 |
That’s not a typo. $5 versus $210 to $850. The API is 42x to 170x cheaper per successful data point. And it returns structured JSON. No parsing step. No broken selectors.
How fast is scraping vs an API?
Speed isn’t even close.
Zillow’s anti-bot system limits safe organic scraping to roughly one request every 3 to 8 seconds, according to the Dev.to benchmark. Go faster and your IP gets blocked. Even with rotating proxies, the benchmark showed average latencies of 6 to 18 seconds per page.
Here’s what that means for real workloads:
| Task | Scraping (best case) | Zillapi API |
|---|---|---|
| 1 property lookup | 6 seconds | ~1 second |
| 100 property lookups | 10 minutes | 50 seconds |
| 1,000 property lookups | 1.7 hours | 5 minutes |
| 10,000 property lookups | 17 hours | 50 minutes |
The API runs at 200 requests per minute on the free and monthly plans. Annual plans get 300 per minute. Enterprise gets 600 per minute.
Scrapers don’t have rate limits in the traditional sense. They have detection thresholds. Cross the threshold and your success rate drops from 98% to zero.
What data do you get from each approach?
A scraper gives you whatever is on the page. An API gives you whatever is in the response schema. They’re surprisingly different.
When you scrape a Zillow property page, you get the visible content: listing price, photos, description text, basic specs. But you need to parse it out of React-rendered HTML. The structure changes without warning. Fields move. Class names rotate. Data that was in one div last week is in a different component this week.
When you call an API, you get typed JSON fields: zestimate (integer), bedrooms (integer), taxAssessedValue (integer), schools (array), priceHistory (array). The schema is documented. It doesn’t change between requests.
Here’s what each approach returns:
| Data point | Scraping | Zillapi API |
|---|---|---|
| Zestimate | Yes (parse from page) | Yes (typed integer) |
| Rent Zestimate | Sometimes | Yes (typed integer) |
| Tax records | Yes (parse from page) | Yes (typed integer) |
| Price history | Yes (parse from JS) | Yes (typed array) |
| Photos | Yes (extract URLs) | Yes (URL array) |
| School ratings | Yes (parse from page) | Yes (typed array) |
| Listing description | Yes | Yes |
| Fields per property | 20-50 (depends on parser) | 300+ (documented schema) |
| Response format | HTML (needs parsing) | JSON (ready to use) |
| Schema stability | Changes without notice | Versioned and stable |
The field count gap is the real story. A scraper typically extracts 20 to 50 fields because that’s what’s visible on the page and worth the parsing effort. The API returns 300+ fields because the data is already structured on the backend.
What does Zillow’s anti-bot system look like?
Zillow doesn’t make scraping easy. Their defense stack is multi-layered, and it got harder in 2025-2026 as the WAF market hit $11 billion globally.
Zillow uses Imperva WAF for network analysis and TLS fingerprinting. Your scraper’s TLS handshake has to look like a real browser. Most HTTP libraries fail this check.
On top of that, JavaScript fingerprinting checks for headless browser indicators like navigator.webdriver and missing plugins. If you’re using Puppeteer or Playwright without stealth patches, you’re detected immediately.
Then there’s dynamic React rendering. The property data loads through JavaScript, not in the initial HTML. You need a full browser engine or a reverse-engineered API call to get the data. Simple HTTP requests return empty pages.
IP reputation filtering blocks datacenter IPs on sight. Even residential proxies face rate limiting if the request pattern looks automated.
All of this means a simple requests.get() in Python returns nothing useful. You need Playwright or Puppeteer with stealth plugins, rotating residential proxies, and random delays. That’s a maintenance burden measured in hours per month.
When does scraping actually make sense?
I’m not going to pretend scraping is always wrong. There are legitimate use cases.
If you need data that no API covers — say, listing descriptions, agent bios, or neighborhood narrative text — scraping might be your only option. APIs return structured fields. They don’t return free-text content that Zillow writes for each listing.
If you’re doing a one-time research project and don’t need ongoing access, a quick scraper might be faster than signing up for an API, learning the endpoints, and writing integration code. Emphasis on “one-time.”
If you’re comparing data across multiple real estate sites (Zillow, Redfin, Realtor.com, Trulia) and want a unified pipeline, scraping gives you one approach for all of them. APIs differ across providers.
For everything else — production apps, recurring data pulls, anything where reliability matters — the API wins on every dimension.
The side-by-side verdict
| Factor | Scraping | REST API (Zillapi) |
|---|---|---|
| Legal risk | Violates ToS, gray area | Licensed access, no risk |
| Cost per 1K requests | $210-850 | $5 |
| Response time | 6-18 seconds | ~1 second |
| Success rate | 61-98% | 99%+ |
| Fields per property | 20-50 | 300+ |
| Response format | HTML (parse yourself) | JSON (ready to use) |
| Maintenance | Hours/month | Zero |
| Setup time | Days (proxies, parser, stealth) | 60 seconds |
| Scales to production | Fragile | Reliable |
The only column where scraping wins is “data you can’t get from an API.” Everything else favors the API by a wide margin.
Start with 100 free API calls
If you’re currently scraping Zillow, try the API for 20 minutes. You might not go back.
Go to zillapi.com. Sign up with your email. Get 100 free credits. No credit card.
Pull a property you’ve been scraping. Compare the fields. Compare the speed. Compare the experience of writing r.json()["data"]["zestimate"] versus parsing a Zestimate out of React-rendered HTML with regex.
For a Python walkthrough, check out our Zillow API Python tutorial. For pricing details, see the full cost breakdown.
Frequently asked questions
Is scraping Zillow legal in 2026?
Scraping Zillow’s publicly visible pages is not clearly illegal, but it violates Zillow’s Terms of Use and carries real legal risk. The 2022 hiQ v. LinkedIn ruling established that scraping public data is not a CFAA violation, but Zillow actively blocks scrapers and could pursue civil claims for terms-of-service breach. If you circumvent their anti-bot defenses, the legal picture gets murkier. For commercial use, a REST API is the safer path.
How much does it cost to scrape Zillow?
Scraping Zillow through a proxy service costs $210 to $850 per 1,000 pages depending on the provider, according to a 2026 benchmark by Dev.to. That does not include the engineering time to build and maintain the scraper. A REST API like Zillapi costs $5 per 1,000 calls with structured JSON responses and zero maintenance. At scale, the API is 40x to 170x cheaper per data point.
How fast is Zillow scraping compared to an API?
Zillow scraping averages 6 to 18 seconds per page across major proxy providers, with safe organic scraping limited to one request every 3 to 8 seconds to avoid detection. A REST API like Zillapi responds in under 1 second cached, with a rate limit of 200 requests per minute on the free tier. For 1,000 properties, scraping takes 1 to 5 hours. The API takes under 5 minutes.
What anti-bot defenses does Zillow use?
Zillow uses Imperva WAF for network analysis and TLS fingerprinting, JavaScript fingerprinting to detect headless browsers, dynamic React rendering that requires browser execution, IP reputation filtering that blocks datacenter IPs, and rate limiting at roughly one request every 3 to 8 seconds. These defenses break most simple scrapers within seconds.
Should I scrape Zillow or use an API?
Use an API for any production application. Scrapers break when Zillow updates their site, cost more per data point at scale, respond 6x to 18x slower, and carry legal risk. A REST API like Zillapi returns structured JSON with 300+ fields per property, responds in under 1 second, costs $0.005 per call, and requires no maintenance. Scraping only makes sense for one-off research where you need data the API does not cover.
What is the best Zillow scraping alternative?
Zillapi is the most direct alternative to scraping Zillow. It returns the same data you would scrape from a Zillow property page, including Zestimates, tax records, photos, price history, and school ratings, but as structured JSON through a REST API. No proxies, no parsing, no anti-bot workarounds. Signup takes 60 seconds and you get 100 free API credits with no credit card required.