# Zillow API + Market KPIs (Bridge Interactive Alternative) (`sian.agency/zillow-scraper-api`) Actor

🏡 The Zillow API replacement — no key, no rate limits, no spreadsheet math. Paste any Zillow URL → listings + Zestimate + total inventory + investor KPIs (gross yield, cap rate, cash flow, price/Zestimate, days-on-market). Bridge Interactive alternative. Bulk URL & CSV input. $0.003/property.

- **URL**: https://apify.com/sian.agency/zillow-scraper-api.md
- **Developed by:** [SIÁN OÜ](https://apify.com/sian.agency) (community)
- **Categories:** Real estate, Automation, Lead generation
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Zillow Scraper API + Market KPIs — The Zillow API Replacement 🏡

[![SIÁN Agency Store](https://img.shields.io/badge/Store-SI%C3%81N%20Agency-1AE392)](https://apify.com/sian.agency?fpr=sian)
[![Smart Idealista Scraper](https://img.shields.io/badge/Store-Smart%20Idealista%20Scraper-97cc64)](https://apify.com/sian.agency/smart-idealista-scraper?fpr=sian)

#### 🎉 The Zillow API replacement — no key, no rate limits, no spreadsheet math. **7 search modes** (URL · address · MLS · polygon · coordinates · map bounds · off-market) → listings + Zestimate + total inventory + investor KPIs in seconds.
##### A drop-in **Bridge Interactive Zillow API alternative** for real estate investors, agents, market researchers, and proptech teams who need reliable US property data **and** the market context to act on it.

### 📋 Overview

**Don't just scrape Zillow — diagnose the market.** Zillow's official API is gated, restricted, and expensive. Paste a Zillow search URL into this scraper — any city, state, ZIP, or filtered search page — and get back clean structured JSON, automatic pagination across all pages, and a market-KPI dashboard built from the data you just pulled. No headless browsers, no broken selectors, no API keys, no maintenance.

Perfect for real estate professionals, investors, lead generation teams, and CRE researchers who need consistent Zillow data at scale.

**Why thousands of professionals choose us:**
- 🧭 **7 search modes**: URL, address, MLS ID, polygon (map-drawn), coordinates+radius, map bounds, off-market — pick how you want to search
- 🌐 **Total inventory count**: We expose `total_results` — see how many listings exist for your search before you even scroll
- 🔄 **Auto-pagination**: One URL → we paginate `/2_p/`, `/3_p/`, ... up to your cap. No manual loops
- 📈 **Investor KPIs out of the box**: Median **gross rental yield**, **price-to-Zestimate**, **price-to-tax-assessed**, **days-on-market**, and **stale-listing share** — computed automatically per run
- 🏘 **Inventory breakdown**: Counts by home type (SFH/condo/townhouse), status, and price/sqft distribution — built in
- ✅ **URL-driven**: Paste any Zillow search URL — pagination, filters, map bounds all preserved
- ⚡ **Fast & reliable**: API-powered extraction, never breaks on Zillow layout changes
- 🎯 **30+ fields per property**: Address, price, Zestimate, beds, baths, sqft, photos, GPS, tax data
- 💰 **Best price**: $0.003 per property — pay only for what you extract
- 📁 **Bulk + CSV input**: Process unlimited search URLs in one run (PAID tier)
- 💎 **Auto deduplication**: Same ZPID across pages? We remove duplicates automatically
- 🆓 **Free tier**: 25 properties per run, no credit card required

### 🧭 7 Search Modes — pick how you want to query Zillow

Set `searchMode` to one of the values below. Each mode reads its own input fields; everything downstream (auto-pagination, KPI computation, HTML report, dedup) is identical.

| Mode | Input fields | Tier | When to use |
|---|---|---|---|
| `url` _(default)_ | `searchUrl` · `searchUrls` · `urlsCsv` | FREE+PAID | You have a Zillow URL with all filters baked in |
| `address` | `addressQuery` · `addressQueries` (PAID) | FREE+PAID | Free-text city/neighborhood/address lookup |
| `mls` | `mlsId` · `mlsIds` (PAID) | FREE+PAID | You know the MLS listing ID |
| `polygon` | `polygonCoords` (array of ≥3 `[lng, lat]` pairs) | **PAID** | Map-drawn polygon search |
| `coordinates` | `centerLat` · `centerLng` · `radiusMiles` (max 50) | FREE+PAID | Center point + radius |
| `mapbounds` | `north` · `south` · `east` · `west` | **PAID** | Bounding-box search |
| `offmarket` | `offmarketZip` (ZIP only — upstream rejects address) | **PAID** | Off-market property sourcing |

**Shared inputs (apply across all modes):**
- `listingStatus` — `For_Sale` (default) · `For_Rent` · `Sold`. Required by every mode except `url` (the URL itself encodes status) and `offmarket`.
- `maxResultsPerQuery` — default **40**, chosen so a default click-Run finishes in exactly **one** upstream API request across every mode. Increase to scrape more pages. FREE tier is always capped at 25.
- `startPage` — default 1. URL mode also honors `/N_p/` suffix on the URL itself.

> ⚙️  Defaults are 100% backward-compatible. If you don't set `searchMode`, the actor runs in `url` mode exactly like v1.0.

### 📈 Market Intelligence (the unfair advantage)

After every run, alongside your dataset you get a `market-kpis.json` record and an HTML report with these signals — **nothing else on the Apify Store returns this**:

| Signal | What it tells you |
|---|---|
| **Gross rental yield (median)** | `(rentZestimate × 12) / price` — buy-to-rent investability at a glance |
| **Cap rate (median)** | NOI / price using a 40% operating expense ratio — true return after operating costs |
| **Estimated monthly cash flow (median)** | Net cash flow at 20% down · 7% mortgage · 30-yr amortization — industry-standard investor underwriting |
| **Price / Zestimate (median)** | <1 means listings are below Zillow's estimate, >1 means above |
| **Price / Tax Assessed (median)** | Sanity check vs municipal valuation — spots overpriced markets |
| **Coverage ratio** | How much of `total_results` your run actually pulled |
| **Stale share** | % of listings on Zillow more than 60 days — hot-vs-cold market read |
| **Days on Zillow** | Min · median · avg · p90 · max — full distribution |
| **Price / area / $-per-sqft / beds / baths** | Min · median · avg · p90 · max for each |
| **Inventory breakdown** | Counts by home type, home status, status type |

> 💡 **Underwriting assumptions** are echoed in every report so you always see what defaults drove a given number — 20% down · 7% mortgage · 40% operating expense ratio · 30-year amortization. These match standard investor norms.

### ✨ Features

- 🔗 **Direct URL Input**: Paste any zillow.com search page — for-sale, for-rent, sold, map searches
- 📋 **Bulk Mode**: Process multiple Zillow URLs in one run (PAID)
- 📁 **CSV Upload**: Drop a CSV of search URLs — Excel/Google Sheets friendly (PAID)
- 🏷️ **Zestimate Included**: Get Zillow's Zestimate and Rent Zestimate values directly
- 📸 **All Photos**: Full image array per listing, not just the thumbnail
- 🗺️ **GPS Coordinates**: Latitude and longitude for every property
- 🏠 **Home Type Detection**: Single family, condo, townhouse, multi-family, land, manufactured
- 📅 **Days on Zillow**: Time-on-market data for hot-list filtering
- 💵 **Tax Assessed Value**: Public assessment data per property
- 🎬 **Media Flags**: 3D model and video tour availability per listing

### 🎬 Quick Start

Paste a Zillow URL → click Run → download structured JSON. That's it.

```bash
curl -X POST https://api.apify.com/v2/acts/sian.agency~zillow-property-scraper/runs?token=YOUR_TOKEN \
-H 'Content-Type: application/json' \
-d '{"searchUrl": "https://www.zillow.com/austin-tx/"}'
````

### 🚀 Getting Started (3 Simple Steps)

#### Step 1: Copy a Zillow Search URL

Go to zillow.com, search for a city or apply filters, and copy the URL from your browser. Examples:

- `https://www.zillow.com/austin-tx/`
- `https://www.zillow.com/los-angeles-ca/houses/`
- `https://www.zillow.com/homes/for_sale/Austin,-TX_rb/`

#### Step 2: Paste & Configure

Paste the URL into `searchUrl`. Set `maxResultsPerUrl` if you want to cap results (FREE tier is always capped at 25).

#### Step 3: Run & Download

Click Run. Download as JSON or CSV when finished.

**That's it! In under a minute, you'll have:**

- Full property records (price, beds, baths, sqft)
- Zestimate and Rent Zestimate per property
- Geographic coordinates for mapping
- All photo URLs and media flags
- Direct Zillow listing URLs for verification

### 📥 Input Configuration

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `searchUrl` | string | Yes (single mode) | Zillow search URL to scrape |
| `searchUrls` | array | No | Bulk array of Zillow URLs (PAID only) |
| `urlsCsv` | array | No | CSV file upload with one URL per line (PAID only) |
| `maxResultsPerUrl` | integer | No | Cap properties returned per URL (default 100, FREE tier capped at 25) |

**Pagination:** Pagination is automatic — the scraper fetches as many pages as needed to satisfy `maxResultsPerUrl`. Each search returns ~42 results per page; total available results are reported in the HTML summary and in `search-totals.json` (key-value store). Optionally append `/N_p/` to start from a specific page (e.g. `https://www.zillow.com/austin-tx/3_p/`).

**Single URL example:**

```json
{
  "searchUrl": "https://www.zillow.com/austin-tx/",
  "maxResultsPerUrl": 100
}
```

**Bulk URLs example (PAID):**

```json
{
  "searchUrls": [
    "https://www.zillow.com/austin-tx/",
    "https://www.zillow.com/miami-fl/",
    "https://www.zillow.com/seattle-wa/"
  ]
}
```

### 📤 Output

Each property is saved to the Apify dataset with **30+ fields** including:

| Field | Type | Description |
|-------|------|-------------|
| `zpid` | string | Zillow property ID (unique) |
| `detailUrl` | string | Direct Zillow listing URL |
| `address` | string | Full street address |
| `addressCity` | string | City |
| `addressState` | string | State (US 2-letter) |
| `addressZipcode` | string | ZIP code |
| `unformattedPrice` | number | Price (raw number) |
| `price` | string | Price (formatted, e.g. "$425,000") |
| `beds` | number | Bedrooms |
| `baths` | number | Bathrooms |
| `area` | number | Living area in square feet |
| `homeType` | string | SINGLE\_FAMILY, CONDO, TOWNHOUSE, etc. |
| `homeStatus` | string | FOR\_SALE, FOR\_RENT, SOLD, etc. |
| `daysOnZillow` | number | Days listed |
| `zestimate` | number | Zillow's value estimate |
| `rentZestimate` | number | Estimated monthly rent |
| `taxAssessedValue` | number | Public tax assessment |
| `latitude` | number | GPS latitude |
| `longitude` | number | GPS longitude |
| `imgSrc` | string | Main photo URL |
| `allImages` | array | All photo URLs |
| `has3DModel` | boolean | 3D virtual tour available |
| `hasVideo` | boolean | Video tour available |

**Example:**

```json
{
  "zpid": "44359547",
  "detailUrl": "https://www.zillow.com/homedetails/...",
  "address": "1234 Riverside Ave, Jacksonville, FL 32204",
  "addressCity": "Jacksonville",
  "addressState": "FL",
  "addressZipcode": "32204",
  "unformattedPrice": 425000,
  "price": "$425,000",
  "beds": 3,
  "baths": 2,
  "area": 1850,
  "homeType": "SINGLE_FAMILY",
  "homeStatus": "FOR_SALE",
  "daysOnZillow": 12,
  "zestimate": 432100,
  "rentZestimate": 2400,
  "taxAssessedValue": 318500,
  "latitude": 30.3322,
  "longitude": -81.6557,
  "imgSrc": "https://photos.zillowstatic.com/...",
  "allImages": ["https://...", "https://..."],
  "has3DModel": false,
  "hasVideo": true
}
```

### 💼 Use Cases & Examples

#### 1. Real Estate Investor Lead Generation

**Investors finding undervalued properties across multiple metros**

**Input:** Bulk Zillow search URLs filtered by max price + min beds
**Output:** All matching listings with Zestimate vs price gap
**Use:** Identify properties priced below Zestimate for off-market outreach

#### 2. Comparable Sales (Comps) Analysis

**Agents and appraisers building CMA reports**

**Input:** Zillow URL filtered by neighborhood + sold-in-last-12-months
**Output:** Recently sold comparables with price, sqft, beds, days on market
**Use:** Generate accurate comparative market analyses in minutes

#### 3. Multi-City Market Research

**Proptech teams tracking pricing trends across markets**

**Input:** CSV with 50+ city search URLs
**Output:** Consolidated dataset with median prices, days on market by city
**Use:** Build market dashboards, quarterly reports, investor decks

#### 4. Rental Yield Calculation

**Buy-to-rent investors analyzing cash flow potential**

**Input:** Zillow for-sale URL + filter for single-family homes
**Output:** Properties with both `unformattedPrice` and `rentZestimate`
**Use:** Calculate gross rental yield = (rentZestimate × 12) / price

#### 5. Real Estate CRM Enrichment

**Agencies enriching lead lists with property data**

**Input:** ZIP-code-specific Zillow URLs matching client portfolios
**Output:** Property records with photos, GPS, Zestimate
**Use:** Auto-populate CRM listings, send branded property alerts

#### 6. Property Tax Arbitrage Research

**Investors comparing taxAssessedValue vs market price**

**Input:** Zillow URL filtered by county + property type
**Output:** Properties with both `taxAssessedValue` and `unformattedPrice`
**Use:** Identify over-assessed properties for tax appeal opportunities

#### 7. Real Estate Aggregator / Directory Sites

**Builders of property directory sites needing seed data**

**Input:** State or city-level Zillow URLs (paginated)
**Output:** Full property catalog with photos, descriptions, geo
**Use:** Bootstrap a property listings directory with structured data

### 🔗 Integration Examples

#### JavaScript/Node.js

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });

const run = await client.actor('sian.agency/zillow-property-scraper').call({
  searchUrl: 'https://www.zillow.com/austin-tx/',
  maxResultsPerUrl: 100
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Found ${items.length} properties`);
```

#### Python

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_TOKEN')

run = client.actor('sian.agency/zillow-property-scraper').call(
    run_input={
        'searchUrl': 'https://www.zillow.com/austin-tx/',
        'maxResultsPerUrl': 100
    }
)

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item['address'], item['unformattedPrice'])
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/sian.agency~zillow-property-scraper/runs?token=YOUR_TOKEN' \
-H 'Content-Type: application/json' \
-d '{"searchUrl": "https://www.zillow.com/los-angeles-ca/"}'
```

#### Automation Workflows (n8n / Zapier / Make)

1. **Trigger**: Schedule (daily/weekly) or new-lead webhook
2. **HTTP Request**: Call this actor with target Zillow URL
3. **Process**: Filter properties by price/beds/Zestimate gap
4. **Action**: Save to Airtable/Google Sheets, send Slack alert, push to CRM

### 📊 Performance & Pricing

#### FREE Tier (Try It Now)

- **25 properties per run** — full feature access, all fields included
- **1 search URL per run**
- No credit card required
- Perfect for testing, single-city research, small projects

#### PAID Tier (Production Ready)

- **Unlimited properties** per run
- **Unlimited search URLs** (bulk + CSV upload)
- Pay-per-result pricing — only charged for properties extracted
- Ideal for investor pipelines, market research, lead gen at scale

#### Pricing Model

- **Start fee:** $0.005 per run
- **Per property:** $0.003

#### Cost Examples

- **25 properties (FREE tier max):** $0.005 + $0.075 = **$0.08**
- **100 properties:** $0.005 + $0.30 = **$0.305**
- **1,000 properties:** $0.005 + $3.00 = **$3.005**

💰 **Best price on the market** — flat $0.003 per property, no hidden fees.

🔗 [View current pricing](https://apify.com/sian.agency/zillow-property-scraper?fpr=sian)

### ❓ Frequently Asked Questions

**Q: Does Zillow have an API?**
A: Zillow no longer offers a public API for property listings. The legacy Zillow Web Services API (GetSearchResults, GetZestimate, etc.) was retired, and the Bridge Interactive API is restricted to Zillow Premier Agents and approved MLS partners. **This actor is the practical replacement** — paste any Zillow search URL and get the same data the official API used to return, plus market KPIs the official API never offered.

**Q: Looking for a Bridge Interactive Zillow API alternative?**
A: You're in the right place. Zillow's Bridge Interactive API requires partner approval, MLS membership, and has strict access criteria. This Zillow Scraper API works on any zillow.com search URL with no key, no MLS affiliation, and no approval process. You get the same property records (address, beds, baths, price, Zestimate, rent Zestimate, GPS, photos, tax data) at $0.003 per property.

**Q: How much does Zillow API access cost?**
A: The official Zillow Bridge API has variable pricing and is gated to approved partners. This Zillow Scraper API is **flat-rate $0.003 per property** (plus $0.005 per run start) — no monthly minimums, no contracts. The FREE tier gives you 25 properties per run, no credit card required.

**Q: How does this Zillow Scraper compare to the official Zillow API?**
A: This actor returns the same core data the official API exposed (listing info, Zestimate, photos, tax history) plus three things the official API does **not** offer: (1) `total_results` for the full search inventory, (2) auto-pagination to your cap, and (3) computed investor KPIs (gross yield, cap rate, monthly cash flow, price-to-Zestimate, days-on-market, stale-listing share).

**Q: Can I use this Zillow scraper from Python?**
A: Yes — call it via the Apify Python SDK or any HTTP client. See the [Python integration example](#python) above. The actor returns clean JSON ready for pandas/polars dataframes.

**Q: Do I need a Zillow API key?**
A: No. There's no Zillow API key, no Bridge Interactive partner approval, no MLS membership. Just an Apify account.

**Q: Which Zillow URLs work?**
A: Any zillow.com search URL — city pages, state pages, filtered searches, map searches, for-sale, for-rent, and sold pages. Single property detail URLs (`/homedetails/...`) are not supported — use a search URL.

**Q: How do I get more than 25 results?**
A: FREE tier caps at 25 per run. Upgrade to PAID for unlimited results. **Pagination is automatic** — set `maxResultsPerUrl` to your target and we'll fetch as many pages as needed.

**Q: Are Zestimate and Rent Zestimate always available?**
A: Almost always for residential listings. Some new construction, land, and commercial listings may not have a Zestimate.

**Q: Does pagination work?**
A: Yes — and it's **automatic**. We paginate `/2_p/`, `/3_p/`, ... until your `maxResultsPerUrl` cap is reached or the search is fully drained. You can still append `/N_p/` manually to start at a specific page.

**Q: Can I filter by price, beds, or property type?**
A: Use Zillow's own filters in your browser, then copy the resulting URL. Filters are preserved in the URL.

**Q: What output formats are available?**
A: JSON, CSV, Excel, HTML — export directly from the Apify dataset.

**Q: Is this legal?**
A: Yes — only publicly available Zillow listings are extracted. See the legal section below.

**Q: How fast is it?**
A: Roughly 1-3 seconds per Zillow search URL fetched, plus per-property processing. A 100-property run typically completes in under 30 seconds.

### 🐛 Troubleshooting

**No results returned**

- Verify the URL works in a browser
- Check the URL is a Zillow search page, not a single property detail page
- Try removing aggressive filters (very narrow price ranges return 0 results)

**Truncated to 25 results on FREE tier**

- This is the FREE tier cap. Upgrade to PAID for unlimited results
- Or paginate with `/2_p/`, `/3_p/` URLs across multiple runs

**Bulk mode rejected on FREE**

- `searchUrls` and `urlsCsv` are PAID-only. FREE users: use `searchUrl` (single)

**Some properties missing Zestimate**

- Zestimate isn't available for every listing (new construction, land, etc.). The field will be `null` when unavailable.

### ⚖️ Is it legal to scrape data?

Our actors are ethical and do not extract any private user data, such as email addresses, gender, or location. They only extract what users have chosen to share publicly on Zillow. We therefore believe that our actors, when used for ethical purposes by Apify users, are safe.

However, you should be aware that your results could contain personal data. Personal data is protected by the **GDPR** in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

You can also read Apify's blog post on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

### 🤝 Support

**Join our active support community**

- For issues or questions, open an issue in the actor's repository
- Check [SIÁN Agency Store](https://apify.com/sian.agency?fpr=sian) for more automation tools
- 📧 <hello@sian-agency.online>

***

**Built by [SIÁN Agency](https://www.sian-agency.online)** | **[More Tools](https://apify.com/sian.agency?fpr=sian)**

**🎯 Not sure which tier you need?** Start with FREE — no credit card required. Upgrade when you're ready to scale.

# Actor input Schema

## `searchMode` (type: `string`):

Pick how you want to search Zillow. Each mode reads its own dedicated input fields below — fields outside the chosen mode are ignored.

• **url** — paste a Zillow search URL (default; cheapest)
• **address** — search by free-text address or city
• **mls** — look up by MLS listing ID
• **polygon** — draw a polygon on a map (PAID)
• **coordinates** — center point + radius
• **mapbounds** — north/south/east/west bounding box (PAID)
• **offmarket** — find off-market properties by address or ZIP (PAID)

## `searchUrl` (type: `string`):

Paste a Zillow search URL, e.g. https://www.zillow.com/austin-tx/. ⚡ Auto-paginates to satisfy 'Max results per query'. 📈 Market KPIs computed automatically. Optionally append /N\_p/ to start from a specific page. Ignored if 'Bulk URLs' or 'CSV upload' is provided.

## `searchUrls` (type: `array`):

Array of Zillow search URLs. PAID tier only. Click 'Bulk edit' to paste URLs (one per line) or upload a .txt file.

## `urlsCsv` (type: `array`):

Upload a CSV file containing Zillow search URLs (one per line, optional header). PAID tier only.

## `addressQuery` (type: `string`):

Free-text address, neighborhood, or city. Examples: '123 Main St, Austin TX 78704', 'Williamsburg, Brooklyn'.

## `addressQueries` (type: `array`):

Array of address strings. PAID tier only.

## `mlsId` (type: `string`):

A single Multiple Listing Service ID, e.g. '6789432'.

## `mlsIds` (type: `array`):

Array of MLS IDs. PAID tier only.

## `polygonCoords` (type: `array`):

Array of at least 3 \[longitude, latitude] pairs forming a polygon ring. Example: \[\[-97.74,30.27],\[-97.71,30.27],\[-97.71,30.30],\[-97.74,30.30]]. PAID tier only.

## `centerLat` (type: `string`):

Decimal latitude of the search center, e.g. '30.2672'.

## `centerLng` (type: `string`):

Decimal longitude of the search center, e.g. '-97.7431'.

## `radiusMiles` (type: `string`):

Search radius in miles, between 0 and 50.

## `north` (type: `string`):

Northern boundary latitude.

## `south` (type: `string`):

Southern boundary latitude.

## `east` (type: `string`):

Eastern boundary longitude.

## `west` (type: `string`):

Western boundary longitude.

## `offmarketZip` (type: `string`):

ZIP code to scan for off-market inventory. Only ZIP is supported by the upstream endpoint.

## `listingStatus` (type: `string`):

Required by Zillow's upstream API for address, MLS, polygon, coordinates, mapbounds modes. Defaults to For\_Sale. Ignored in URL mode (the URL itself encodes status) and offmarket mode.

## `maxResultsPerQuery` (type: `integer`):

📊 Hard cap on properties returned per query. We auto-paginate until this cap is reached or the search is fully drained. Default is 40 — chosen so a default click-Run always finishes in exactly ONE upstream API request (URL mode returns ~41/page, geo modes return up to 200/page). Increase to scrape more pages. The total available count is reported in 'Search Totals' regardless of this cap. FREE tier is always capped at 25.

## `startPage` (type: `integer`):

📄 Page number to start pagination from. Default 1 (first page). Useful for resuming long searches or skipping already-processed pages. In url mode, if a URL ends with /N\_p/ that suffix is honored when this field is left at 1.

## Actor input object example

```json
{
  "searchMode": "url",
  "searchUrl": "https://www.zillow.com/los-angeles-ca/",
  "addressQuery": "Austin, TX 78704",
  "centerLat": "30.2672",
  "centerLng": "-97.7431",
  "radiusMiles": "5",
  "offmarketZip": "78704",
  "listingStatus": "For_Sale",
  "maxResultsPerQuery": 40,
  "startPage": 1
}
```

# Actor output Schema

## `results` (type: `string`):

Structured Zillow property listings.

## `htmlReport` (type: `string`):

HTML summary with run stats, market KPIs, distribution, and per-URL totals.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "searchUrl": "https://www.zillow.com/austin-tx/"
};

// Run the Actor and wait for it to finish
const run = await client.actor("sian.agency/zillow-scraper-api").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "searchUrl": "https://www.zillow.com/austin-tx/" }

# Run the Actor and wait for it to finish
run = client.actor("sian.agency/zillow-scraper-api").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchUrl": "https://www.zillow.com/austin-tx/"
}' |
apify call sian.agency/zillow-scraper-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=sian.agency/zillow-scraper-api",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Zillow API + Market KPIs (Bridge Interactive Alternative)",
        "description": "🏡 The Zillow API replacement — no key, no rate limits, no spreadsheet math. Paste any Zillow URL → listings + Zestimate + total inventory + investor KPIs (gross yield, cap rate, cash flow, price/Zestimate, days-on-market). Bridge Interactive alternative. Bulk URL & CSV input. $0.003/property.",
        "version": "1.0",
        "x-build-id": "bmI1uPeFhtd1bRx5O"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sian.agency~zillow-scraper-api/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sian.agency-zillow-scraper-api",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/sian.agency~zillow-scraper-api/runs": {
            "post": {
                "operationId": "runs-sync-sian.agency-zillow-scraper-api",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/sian.agency~zillow-scraper-api/run-sync": {
            "post": {
                "operationId": "run-sync-sian.agency-zillow-scraper-api",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchMode": {
                        "title": "🧭 Search Mode",
                        "enum": [
                            "url",
                            "address",
                            "mls",
                            "polygon",
                            "coordinates",
                            "mapbounds",
                            "offmarket"
                        ],
                        "type": "string",
                        "description": "Pick how you want to search Zillow. Each mode reads its own dedicated input fields below — fields outside the chosen mode are ignored.\n\n• **url** — paste a Zillow search URL (default; cheapest)\n• **address** — search by free-text address or city\n• **mls** — look up by MLS listing ID\n• **polygon** — draw a polygon on a map (PAID)\n• **coordinates** — center point + radius\n• **mapbounds** — north/south/east/west bounding box (PAID)\n• **offmarket** — find off-market properties by address or ZIP (PAID)",
                        "default": "url"
                    },
                    "searchUrl": {
                        "title": "🔗 Zillow Search URL  (used when Search Mode = url)",
                        "pattern": "^https?://(www\\.)?zillow\\.com/.+",
                        "type": "string",
                        "description": "Paste a Zillow search URL, e.g. https://www.zillow.com/austin-tx/. ⚡ Auto-paginates to satisfy 'Max results per query'. 📈 Market KPIs computed automatically. Optionally append /N_p/ to start from a specific page. Ignored if 'Bulk URLs' or 'CSV upload' is provided."
                    },
                    "searchUrls": {
                        "title": "📋 Bulk URLs  (PAID, url mode)",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Array of Zillow search URLs. PAID tier only. Click 'Bulk edit' to paste URLs (one per line) or upload a .txt file.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "urlsCsv": {
                        "title": "📁 CSV Upload  (PAID, url mode)",
                        "type": "array",
                        "description": "Upload a CSV file containing Zillow search URLs (one per line, optional header). PAID tier only.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "addressQuery": {
                        "title": "🏠 Address  (used when Search Mode = address)",
                        "type": "string",
                        "description": "Free-text address, neighborhood, or city. Examples: '123 Main St, Austin TX 78704', 'Williamsburg, Brooklyn'."
                    },
                    "addressQueries": {
                        "title": "📋 Bulk Addresses  (PAID, address mode)",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Array of address strings. PAID tier only.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "mlsId": {
                        "title": "🆔 MLS ID  (used when Search Mode = mls)",
                        "type": "string",
                        "description": "A single Multiple Listing Service ID, e.g. '6789432'."
                    },
                    "mlsIds": {
                        "title": "📋 Bulk MLS IDs  (PAID, mls mode)",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Array of MLS IDs. PAID tier only.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "polygonCoords": {
                        "title": "📐 Polygon Coordinates  (PAID, polygon mode)",
                        "type": "array",
                        "description": "Array of at least 3 [longitude, latitude] pairs forming a polygon ring. Example: [[-97.74,30.27],[-97.71,30.27],[-97.71,30.30],[-97.74,30.30]]. PAID tier only."
                    },
                    "centerLat": {
                        "title": "🌐 Center Latitude  (used when Search Mode = coordinates)",
                        "type": "string",
                        "description": "Decimal latitude of the search center, e.g. '30.2672'."
                    },
                    "centerLng": {
                        "title": "🌐 Center Longitude  (used when Search Mode = coordinates)",
                        "type": "string",
                        "description": "Decimal longitude of the search center, e.g. '-97.7431'."
                    },
                    "radiusMiles": {
                        "title": "📏 Radius (miles)  (used when Search Mode = coordinates)",
                        "type": "string",
                        "description": "Search radius in miles, between 0 and 50."
                    },
                    "north": {
                        "title": "🧭 North Latitude  (PAID, mapbounds mode)",
                        "type": "string",
                        "description": "Northern boundary latitude."
                    },
                    "south": {
                        "title": "🧭 South Latitude  (PAID, mapbounds mode)",
                        "type": "string",
                        "description": "Southern boundary latitude."
                    },
                    "east": {
                        "title": "🧭 East Longitude  (PAID, mapbounds mode)",
                        "type": "string",
                        "description": "Eastern boundary longitude."
                    },
                    "west": {
                        "title": "🧭 West Longitude  (PAID, mapbounds mode)",
                        "type": "string",
                        "description": "Western boundary longitude."
                    },
                    "offmarketZip": {
                        "title": "📮 Off-market ZIP  (PAID, offmarket mode)",
                        "type": "string",
                        "description": "ZIP code to scan for off-market inventory. Only ZIP is supported by the upstream endpoint."
                    },
                    "listingStatus": {
                        "title": "🏷 Listing Status  (required for non-URL modes)",
                        "enum": [
                            "For_Sale",
                            "For_Rent",
                            "Sold"
                        ],
                        "type": "string",
                        "description": "Required by Zillow's upstream API for address, MLS, polygon, coordinates, mapbounds modes. Defaults to For_Sale. Ignored in URL mode (the URL itself encodes status) and offmarket mode.",
                        "default": "For_Sale"
                    },
                    "maxResultsPerQuery": {
                        "title": "📊 Max results per query",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "📊 Hard cap on properties returned per query. We auto-paginate until this cap is reached or the search is fully drained. Default is 40 — chosen so a default click-Run always finishes in exactly ONE upstream API request (URL mode returns ~41/page, geo modes return up to 200/page). Increase to scrape more pages. The total available count is reported in 'Search Totals' regardless of this cap. FREE tier is always capped at 25.",
                        "default": 40
                    },
                    "startPage": {
                        "title": "📄 Start Page",
                        "minimum": 1,
                        "type": "integer",
                        "description": "📄 Page number to start pagination from. Default 1 (first page). Useful for resuming long searches or skipping already-processed pages. In url mode, if a URL ends with /N_p/ that suffix is honored when this field is left at 1.",
                        "default": 1
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
