Best Web Scraping APIs for Zillow: July 2026 Benchmark

Scrapfly is the best web scraping API for Zillow, with a 98% success rate across 8 web scraping APIs benchmarked against live Zillow pages in July 2026. 4 of the 8 cleared Zillow reliably enough to recommend.

Zillow is protected by PerimeterX (HUMAN), so most scraping APIs either fail it or pay for it in speed and cost. The benchmark is refreshed twice a month, with no affiliate links and no sponsors.

Ranked by live Zillow success rate, best first:

1. 🥇 Scrapfly: 98% success on Zillow
2. 🥈 WebScrapingAPI: 98% success on Zillow
3. 🥉 Firecrawl: 96% success on Zillow

All 6 web scraping APIs for Zillow, ranked

#	Service	Success	Speed	Cost/1k		Code
1 🥇	Scrapfly	98%	5.7s	$3.9	(237) ★ 4.9	code
2 🥈	WebScrapingAPI	98%	17.4s	$2.71	n/a	code
3 🥉	Firecrawl	96%	5.0s	$6.33	n/a	code
4	Scraperapi	93%	4.4s	$0.49	(62) ★ 4.6	code
5	Scrapingdog	13%	6.7s	$5.0	n/a	code
6	Scrapingant	4%	13.5s	$1.9	n/a	code

Data range Jul 31 to Aug 14

Ranking history: web scraping APIs for Zillow over time

The 6 web scraping APIs for Zillow, reviewed

1. Scrapfly: 98% success on Zillow

Zillow puts PerimeterX in front of its property, search, and map pages, and the listing data sits in a large embedded JSON state rather than the visible HTML. Scrapfly cleared 98% here by generating a genuine browser fingerprint and passing PerimeterX's sensor and cookie checks, so it reaches the rendered page and the embedded JSON instead of a challenge screen. Because it only bills for successful requests, the "Press & Hold" and block pages Zillow returns as a 200 don't quietly run up the cost.

At $3.90 per 1,000 successful requests and 5.7s average response time, the figures are strong for an API capable of clearing PerimeterX. The 98% success rate is the headline, and the ranking history above shows how that rate has held across previous runs.

Pros:

• Highest success rate in the test, clearing PerimeterX's sensor and cookie checks
• Only charges for successful scrapes, so challenge pages returned as 200s cost nothing
• One asp flag plus residential proxies handles Zillow with little tuning
• First class SDKs for Python, TypeScript, Go, and Rust, plus a Scrapy extension

Cons:

• Credit cost per request rises once ASP, JavaScript rendering, or residential proxies are enabled
• The entry (Discovery) plan caps concurrency at 5, so large map/search crawls need a higher tier
• The free tier is a single batch of 1,000 credits, enough to prototype but not to benchmark at volume

2. WebScrapingAPI: 98% success on Zillow

WebScrapingAPI covers a broad range of language SDKs behind a simple REST interface, so it drops into most stacks without a client library, and it supports async and batch submission for queued jobs. The scorecard carries this run's speed and cost. On Zillow it cleared 98% this run.

Pros:

• Broad language SDK range behind a simple REST interface
• Async and batch submission for queued jobs

Cons:

• PerimeterX's block pages return as 200s, so it's easy to keep paying unless you check content
• Support tickets often go unanswered for days, per user reviews

3. Firecrawl: 96% success on Zillow

Firecrawl's draw on Zillow is its output format. It returns structured markdown rather than raw HTML, so a pipeline feeding an LLM or RAG system skips the parsing step on Zillow's page markup. Rendering a full browser on every page and generating that markdown carries a cost and latency premium over lighter, HTTP based options, so that saving has to be worth the premium for your use case. On Zillow it cleared 96% this run.

Pros:

• Returns markdown built for LLM pipelines, saving a parsing step for AI and RAG pipelines
• Runs a real browser, which covers pages that need JavaScript execution

Cons:

• Cost is the top user complaint in reviews
• Renders a full browser on every page, which adds latency

4. Scraperapi: 93% success on Zillow

Scraperapi is built around a fast request path. When it clears a request it tends to return quickly, which suits latency sensitive lookups that can absorb retries. Zillow's PerimeterX layer has to be cleared before the embedded JSON state is reachable, and the scorecard carries how it did on that this run. On Zillow it cleared 93% this run.

Pros:

• Fast when it clears, with a simple integration
• Broad language SDK support

Cons:

• Login required flows and form filling are off limits
• Geotargeting is gated by plan (US and EU only until the Business tier)

5. Scrapingdog: 13% success on Zillow

Scrapingdog offers low entry pricing and a simple API, without first party SDKs. PerimeterX scores each request against its sensor and cookie signals before returning the page. On Zillow it cleared 13% this run.

Pros:

• Low entry pricing
• Simple API

Cons:

• No first party SDKs
• Reviewers frequently cite slow, email only support with no live chat option

6. Scrapingant: 4% success on Zillow

Scrapingant bundles JavaScript rendering and session support at a low entry price, with a smaller feature surface than the larger providers. On Zillow it cleared 4% this run.

Pros:

• Low sticker price
• JavaScript rendering included

Cons:

• Smaller feature surface and fewer integration options than the larger providers
• Billing covers requests that return block or challenge pages, so failures still cost credits
• Small provider with a thin public track record

About scraping Zillow

Zillow is the largest US real estate marketplace, and the data people scrape from it is mostly property detail. That means listing prices, the Zestimate valuation, addresses, beds and baths and square footage, lot size, photos, price and tax history, days on market, and agent or listing broker details. Most of this lives on property detail pages (the /homedetails/ URLs) and on search and map area results.

Zillow is an application that leans heavily on JavaScript, so the visible HTML is only a shell. The reliable place to read data is the large embedded JSON state in the page (and the map/search endpoints behind it), which holds the structured property and search records in one object rather than scattered DOM nodes. A genuine browser context matters more for getting past the antibot layer than for rendering, and map area searches paginate through secondary requests.

Zillow is protected by PerimeterX (now HUMAN). See the PerimeterX benchmark page for how PerimeterX detects bots. The practical detail for scraping Zillow is that its blocks and "Press & Hold" challenges come back as a 200 rather than a hard error, so success has to be measured on response content, not status codes.

import json
from parsel import Selector

# install using `pip install scrapfly-sdk`
from scrapfly import ScrapflyClient, ScrapeConfig, ScrapeApiResponse

# create an API client instance
client = ScrapflyClient(key="YOUR API KEY")

# create scrape function that returns HTML parser for a given URL
def scrape(url: str, country: str="", render_js=False, headers: dict=None) -> Selector:
    api_result = client.scrape(ScrapeConfig(
            url=url,
            headers=headers,
            asp=True,
            render_js=render_js or False,
            cache=False,
            cache_ttl=900,
            method='GET',
    ))
    return api_result.selector

url = "https://www.zillow.com/homedetails/1414-1416-20th-Ave-San-Francisco-CA-94122/332857311_zpid/"
selector = scrape(url)

# The entire dataset can be found in a javascript variable:
data = selector.css("script#__NEXT_DATA__::text").get()
data = json.loads(data)["props"]["pageProps"]["componentProps"]["gdpClientCache"]
property_data = list(json.loads(data).values())[0]['property']

# the resulting dataset is pretty big but here are some example fields:
from pprint import pprint
pprint(property_data)

  {
  "listingDataSource": "Phoenix",
  "zpid": 332857311,
  "city": "San Francisco",
  "state": "CA",
  "homeStatus": "FOR_SALE",
  "address": {
  "streetAddress": "1414-1416 20th Ave",
  "city": "San Francisco",
  "state": "CA",
  "zipcode": "94122",
  "neighborhood": null,
  "community": null,
  "subdivision": null
  },
  "bedrooms": 7,
  "bathrooms": 3,
  "price": 1695000,
  "yearBuilt": 1924,
  "streetAddress": "1414-1416 20th Ave",
  "zipcode": "94122",
  # ...
  # and much more
  # ...
  }

import json
from parsel import Selector

# webscrapingapi has a Python SDK but it's not great, use httpx instead:
# `pip install httpx`
import httpx

# create an API client instance
client = httpx.Client(timeout=180)

# create scrape function that returns HTML parser for a given URL
def scrape(url: str, country: str="", render_js=False, headers: dict=None) -> Selector:
    api_result = client.get(
        "https://api.webscrapingapi.com/v2",  # the target url is passed as a parameter below
        headers=headers,
        params={
            "url": url,
            "api_key": "YOUR API KEY",  # NOTE: add your API KEY here!
            "timeout": 60_000,
            "render_js": render_js or False,
            "method": 'GET',
        },
    )
    assert api_result.status_code == 200, api_result.reason_phrase
    return Selector(api_result.text)

url = "https://www.zillow.com/homedetails/1414-1416-20th-Ave-San-Francisco-CA-94122/332857311_zpid/"
selector = scrape(url)

# The entire dataset can be found in a javascript variable:
data = selector.css("script#__NEXT_DATA__::text").get()
data = json.loads(data)["props"]["pageProps"]["componentProps"]["gdpClientCache"]
property_data = list(json.loads(data).values())[0]['property']

# the resulting dataset is pretty big but here are some example fields:
from pprint import pprint
pprint(property_data)

  {
  "listingDataSource": "Phoenix",
  "zpid": 332857311,
  "city": "San Francisco",
  "state": "CA",
  "homeStatus": "FOR_SALE",
  "address": {
  "streetAddress": "1414-1416 20th Ave",
  "city": "San Francisco",
  "state": "CA",
  "zipcode": "94122",
  "neighborhood": null,
  "community": null,
  "subdivision": null
  },
  "bedrooms": 7,
  "bathrooms": 3,
  "price": 1695000,
  "yearBuilt": 1924,
  "streetAddress": "1414-1416 20th Ave",
  "zipcode": "94122",
  # ...
  # and much more
  # ...
  }

import json
from parsel import Selector

# install using `pip install firecrawl-py`
from firecrawl import Firecrawl

# create an API client instance
client = Firecrawl(api_key="YOUR API KEY")

# create scrape function that returns HTML parser for a given URL
def scrape(url: str, country: str="", render_js=False, headers: dict=None) -> Selector:
    api_result = client.scrape(
        url=url,
        headers=headers or {},
        formats=['rawHtml'],
        only_main_content=False,
        skip_tls_verification=False,
        timeout=150000,
        store_in_cache=False,
        max_age=900,
    )
    assert api_result.raw_html, "firecrawl returned no html for this page"
    return Selector(api_result.raw_html)

url = "https://www.zillow.com/homedetails/1414-1416-20th-Ave-San-Francisco-CA-94122/332857311_zpid/"
selector = scrape(url)

# The entire dataset can be found in a javascript variable:
data = selector.css("script#__NEXT_DATA__::text").get()
data = json.loads(data)["props"]["pageProps"]["componentProps"]["gdpClientCache"]
property_data = list(json.loads(data).values())[0]['property']

# the resulting dataset is pretty big but here are some example fields:
from pprint import pprint
pprint(property_data)

  {
  "listingDataSource": "Phoenix",
  "zpid": 332857311,
  "city": "San Francisco",
  "state": "CA",
  "homeStatus": "FOR_SALE",
  "address": {
  "streetAddress": "1414-1416 20th Ave",
  "city": "San Francisco",
  "state": "CA",
  "zipcode": "94122",
  "neighborhood": null,
  "community": null,
  "subdivision": null
  },
  "bedrooms": 7,
  "bathrooms": 3,
  "price": 1695000,
  "yearBuilt": 1924,
  "streetAddress": "1414-1416 20th Ave",
  "zipcode": "94122",
  # ...
  # and much more
  # ...
  }

import json
from parsel import Selector

# install using `pip install scraperapi-sdk`
from scraperapi_sdk import ScraperAPIClient

# create an API client instance
client = ScraperAPIClient(api_key="YOUR API KEY")

# create scrape function that returns HTML parser for a given URL
def scrape(url: str, country: str="", render_js=False, headers: dict=None) -> Selector:
    api_result = client.make_request(
        url=url,
        headers=headers,
        params={
            "render": False,
        },
        method='GET',
    )
    assert api_result.ok, api_result.text
    return Selector(api_result.text)

url = "https://www.zillow.com/homedetails/1414-1416-20th-Ave-San-Francisco-CA-94122/332857311_zpid/"
selector = scrape(url)

# The entire dataset can be found in a javascript variable:
data = selector.css("script#__NEXT_DATA__::text").get()
data = json.loads(data)["props"]["pageProps"]["componentProps"]["gdpClientCache"]
property_data = list(json.loads(data).values())[0]['property']

# the resulting dataset is pretty big but here are some example fields:
from pprint import pprint
pprint(property_data)

  {
  "listingDataSource": "Phoenix",
  "zpid": 332857311,
  "city": "San Francisco",
  "state": "CA",
  "homeStatus": "FOR_SALE",
  "address": {
  "streetAddress": "1414-1416 20th Ave",
  "city": "San Francisco",
  "state": "CA",
  "zipcode": "94122",
  "neighborhood": null,
  "community": null,
  "subdivision": null
  },
  "bedrooms": 7,
  "bathrooms": 3,
  "price": 1695000,
  "yearBuilt": 1924,
  "streetAddress": "1414-1416 20th Ave",
  "zipcode": "94122",
  # ...
  # and much more
  # ...
  }

import json
from parsel import Selector

# scrapingdog has no integration but we can use httpx
# install using `pip install httpx`
import httpx

# create an API client instance
client = httpx.Client(timeout=180)

# create scrape function that returns HTML parser for a given URL
def scrape(url: str, country: str="", render_js=False, headers: dict=None) -> Selector:
    params = {
        "api_key": "YOUR API KEY",
        "url": url,
    }
    api_result = client.get(
        'https://api.scrapingdog.com/scrape',
        params=params,
    )
    assert api_result.status_code == 200, api_result.text
    return Selector(api_result.text, type="html")

url = "https://www.zillow.com/homedetails/1414-1416-20th-Ave-San-Francisco-CA-94122/332857311_zpid/"
selector = scrape(url)

# The entire dataset can be found in a javascript variable:
data = selector.css("script#__NEXT_DATA__::text").get()
data = json.loads(data)["props"]["pageProps"]["componentProps"]["gdpClientCache"]
property_data = list(json.loads(data).values())[0]['property']

# the resulting dataset is pretty big but here are some example fields:
from pprint import pprint
pprint(property_data)

  {
  "listingDataSource": "Phoenix",
  "zpid": 332857311,
  "city": "San Francisco",
  "state": "CA",
  "homeStatus": "FOR_SALE",
  "address": {
  "streetAddress": "1414-1416 20th Ave",
  "city": "San Francisco",
  "state": "CA",
  "zipcode": "94122",
  "neighborhood": null,
  "community": null,
  "subdivision": null
  },
  "bedrooms": 7,
  "bathrooms": 3,
  "price": 1695000,
  "yearBuilt": 1924,
  "streetAddress": "1414-1416 20th Ave",
  "zipcode": "94122",
  # ...
  # and much more
  # ...
  }

import json
from parsel import Selector

# install using `pip install scrapingant-client`
from scrapingant_client import ScrapingAntClient

# create an API client instance
client = ScrapingAntClient(token="YOUR API KEY")

# create scrape function that returns HTML parser for a given URL
def scrape(url: str, country: str="", render_js=False, headers: dict=None) -> Selector:
    api_result = client.general_request(
        url,
    )
    # the scrapingant client returns its own Response object: content holds the page
    assert api_result.status_code == 200, api_result.text
    return Selector(api_result.content)

url = "https://www.zillow.com/homedetails/1414-1416-20th-Ave-San-Francisco-CA-94122/332857311_zpid/"
selector = scrape(url)

# The entire dataset can be found in a javascript variable:
data = selector.css("script#__NEXT_DATA__::text").get()
data = json.loads(data)["props"]["pageProps"]["componentProps"]["gdpClientCache"]
property_data = list(json.loads(data).values())[0]['property']

# the resulting dataset is pretty big but here are some example fields:
from pprint import pprint
pprint(property_data)

  {
  "listingDataSource": "Phoenix",
  "zpid": 332857311,
  "city": "San Francisco",
  "state": "CA",
  "homeStatus": "FOR_SALE",
  "address": {
  "streetAddress": "1414-1416 20th Ave",
  "city": "San Francisco",
  "state": "CA",
  "zipcode": "94122",
  "neighborhood": null,
  "community": null,
  "subdivision": null
  },
  "bedrooms": 7,
  "bathrooms": 3,
  "price": 1695000,
  "yearBuilt": 1924,
  "streetAddress": "1414-1416 20th Ave",
  "zipcode": "94122",
  # ...
  # and much more
  # ...
  }

import json
from parsel import Selector

# install using `pip install zenrows`
from zenrows import ZenRowsClient

# create an API client instance
client = ZenRowsClient(apikey="YOUR API KEY")

# create scrape function that returns HTML parser for a given URL
def scrape(url: str, country: str="", render_js=False, headers: dict=None) -> Selector:
    api_result = client.get(
        url,
        headers=headers,
        params={
        }
    )
    # zenrows answers with the page HTML; "json_response" is only accepted with js_render on
    assert api_result.ok, api_result.text
    return Selector(api_result.text)

url = "https://www.zillow.com/homedetails/1414-1416-20th-Ave-San-Francisco-CA-94122/332857311_zpid/"
selector = scrape(url)

# The entire dataset can be found in a javascript variable:
data = selector.css("script#__NEXT_DATA__::text").get()
data = json.loads(data)["props"]["pageProps"]["componentProps"]["gdpClientCache"]
property_data = list(json.loads(data).values())[0]['property']

# the resulting dataset is pretty big but here are some example fields:
from pprint import pprint
pprint(property_data)

  {
  "listingDataSource": "Phoenix",
  "zpid": 332857311,
  "city": "San Francisco",
  "state": "CA",
  "homeStatus": "FOR_SALE",
  "address": {
  "streetAddress": "1414-1416 20th Ave",
  "city": "San Francisco",
  "state": "CA",
  "zipcode": "94122",
  "neighborhood": null,
  "community": null,
  "subdivision": null
  },
  "bedrooms": 7,
  "bathrooms": 3,
  "price": 1695000,
  "yearBuilt": 1924,
  "streetAddress": "1414-1416 20th Ave",
  "zipcode": "94122",
  # ...
  # and much more
  # ...
  }

import json
from parsel import Selector

# install using `pip install scrapingbee`
from scrapingbee import ScrapingBeeClient

# create an API client instance
client = ScrapingBeeClient(api_key="YOUR API KEY")

# create scrape function that returns HTML parser for a given URL
def scrape(url: str, country: str="", render_js=False, headers: dict=None) -> Selector:
    api_result = client.get(
        url,
        headers=headers,
        params={
            "json_response": True,
            "transparent_status_code": True,
        }
    )
    assert api_result.ok, api_result.text
    data = api_result.json()
    return Selector(data['body'])

url = "https://www.zillow.com/homedetails/1414-1416-20th-Ave-San-Francisco-CA-94122/332857311_zpid/"
selector = scrape(url)

# The entire dataset can be found in a javascript variable:
data = selector.css("script#__NEXT_DATA__::text").get()
data = json.loads(data)["props"]["pageProps"]["componentProps"]["gdpClientCache"]
property_data = list(json.loads(data).values())[0]['property']

# the resulting dataset is pretty big but here are some example fields:
from pprint import pprint
pprint(property_data)

  {
  "listingDataSource": "Phoenix",
  "zpid": 332857311,
  "city": "San Francisco",
  "state": "CA",
  "homeStatus": "FOR_SALE",
  "address": {
  "streetAddress": "1414-1416 20th Ave",
  "city": "San Francisco",
  "state": "CA",
  "zipcode": "94122",
  "neighborhood": null,
  "community": null,
  "subdivision": null
  },
  "bedrooms": 7,
  "bathrooms": 3,
  "price": 1695000,
  "yearBuilt": 1924,
  "streetAddress": "1414-1416 20th Ave",
  "zipcode": "94122",
  # ...
  # and much more
  # ...
  }

How to choose a web scraping API for Zillow

Because Zillow sits behind PerimeterX, start by narrowing to the providers still clearing it this run (the top of the ranked table), then choose within that set based on your job. Low volume property lookups give you more room on cost. Large map area and search crawls put more weight on reliability and concurrency.

• Reliability first. Scrapfly leads the current Zillow ranking, which makes it the default starting point for production search and map crawls. The ranking history shows its track record.
• Value. Among the APIs still clearing Zillow, sort by cost per successful request. The cheapest sticker price is rarely the cheapest per usable Zillow page.
• Speed. For latency sensitive property lookups rather than bulk crawls, pick the fastest option that still clears Zillow reliably.

The key principle is to judge on cost per successful request, not sticker price. PerimeterX returns block and challenge pages as a 200, so a cheap API can look like it's working while delivering empty pages, which makes its real cost per usable result far higher than the rate card suggests.

How we benchmark web scraping APIs for Zillow

We independently benchmark 8 web scraping APIs against live Zillow pages, 1,000+ requests per service, twice a month. Every API is tested against the same Zillow URLs at the same time, and cost is measured per 1,000 successful requests on entry plan pricing. We pay for the plans ourselves. No affiliate links. No sponsors. Just data.

8 APIs · 1,000+ requests each · twice a month · no affiliate links, no sponsors

Benchmarking Zillow has one wrinkle worth knowing about. Success is measured on response content, not HTTP status codes. PerimeterX's "Press & Hold" and soft blocked responses return a 200, so a test that only checked for a 200 would overstate results. We verify that responses contain the expected property data before counting them as successful. Every provider is tested against the same URLs in the same run, so the numbers stay comparable. Latest data: Jul 31 to Aug 14, 2026.

Frequently asked questions about scraping Zillow

Is it legal to scrape Zillow?

Scraping publicly available Zillow data such as listing prices and property details is generally treated as lower risk than scraping data behind a login, but Zillow's Terms of Service prohibit automated access, and agent contact details can fall under privacy laws. Legality depends on what you collect, where you operate, and how you use the data, so treat this as general information rather than legal advice and check your own situation.

What's the cheapest API that works on Zillow?

Sort the ranked table by cost per successful request and read down to the first provider still clearing Zillow this run. That's the cheapest option that actually delivers. Lower priced APIs further down often fail too many requests for their sticker price to be meaningful, and PerimeterX's soft blocking hides those failures unless you check response content.

Do I need a headless browser to scrape Zillow?

In practice yes for reaching the page reliably. Zillow runs PerimeterX and is an application that leans heavily on JavaScript, so a genuine browser context is what clears the challenge. Once you have the HTML, the data is in the embedded JSON state rather than scattered DOM nodes. The APIs at the top of the ranking handle the browser and antibot layer for you.

Why do some APIs score 0% on Zillow?

Because PerimeterX validates its cookie against the sensor telemetry that produced it and blocks requests it can't verify. A request based tool may return 200 responses that are actually "Press & Hold" or block pages, and since we score on response content, those count as failures rather than successes.

How often is this benchmark updated?

Twice a month against the same live Zillow targets, 1,000+ requests per API each run. We publish after validating the run and checking failures for configuration or detection errors.

Conclusion

Zillow sits behind PerimeterX and serves its data through a large embedded JSON state, so the right web scraping API is one that clears the sensor challenge reliably and reaches the rendered page. For production search and map crawls, start with Scrapfly, the highest success rate in the current run. For cost or speed on lighter property page jobs, choose among the providers still clearing Zillow this run.

Whatever you pick, verify results on response content rather than status codes, because PerimeterX's challenge and block pages both return a 200. The benchmark refreshes twice a month, so check the live Zillow results before committing.

Protected by: PerimeterX  ·  Other real estate targets: Realtor  ·  Hub: All target benchmarks