# Zillow Scraper: For Sale, Rentals & Sold Homes (`automation-lab/zillow-scraper`) Actor

Scrape Zillow homes for sale, rentals and sold homes by city, ZIP, address or URL. Filter by price, beds, baths and property type. Get prices, Zestimates, photos, tax values, agents, schools and price history. Export JSON, CSV or Excel.

- **URL**: https://apify.com/automation-lab/zillow-scraper.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** Real estate, Lead generation
- **Features:** Limited permissions
- **Stats:** 220 total users, 11 monthly users, 91.0% runs succeeded, 3 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 listing scrapeds

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Zillow Scraper

🏠 Scrape Zillow homes for sale, rentals and recently sold homes. Search by city, ZIP code, address or Zillow URL, filter by price, beds, baths and property type, and export prices, Zestimates, photos, tax values and 30+ fields per listing.

### What does Zillow Scraper do?

[Zillow Scraper](https://apify.com/automation-lab/zillow-scraper) extracts property listing data from **Zillow.com** — the largest real estate marketplace in the US. Provide a search query (city, ZIP code, or address), paste Zillow search URLs, or supply direct property page links. Every search row includes **price, Zestimate, rent Zestimate, bedrooms, bathrooms, square footage, lot size, property type, days on Zillow, tax assessed value, broker, coordinates and all listing photos**. Turn on `includeDetails` (or pass property URLs) to add **description, year built, agent name and phone, MLS ID, annual tax, HOA fee, nearby schools and price history** from each property page.

No API key or Zillow account needed. Works with residential proxies for reliable extraction.

### Who is it for?

🏡 **Real estate investors & analysts**

- Track property prices across target markets and ZIP codes
- Compare listing prices vs. Zestimates to find undervalued properties
- Monitor days-on-market trends to spot cooling or heating neighborhoods

📊 **Market researchers & data scientists**

- Build datasets of property characteristics by city, state, or region
- Analyze pricing patterns across property types (single-family, condo, townhouse)
- Study correlations between school ratings, HOA fees, and property values

🏗️ **Real estate agents & brokerages**

- Generate comparable listings (comps) for client presentations
- Track competitor listings in your farm area
- Export data to CRM or Google Sheets for lead nurturing

💼 **PropTech startups & developers**

- Feed property data into valuation models or rental yield calculators
- Power home search features with up-to-date listing data
- Enrich address databases with Zillow's property attributes

### Why use Zillow Scraper?

- 🔑 **No Zillow account or API key needed** — uses public guest access
- 🏠 **Unified actor** — search + detail pages in one tool (competitors need 2-3 separate actors)
- 💰 **Pay-per-result pricing** — only pay for listings you extract, no monthly subscription
- 🗺️ **Flexible input** — city names, ZIP codes, addresses, or raw Zillow URLs
- 🔄 **30+ fields per listing** — price, Zestimate, beds/baths, sqft, tax data, photos, schools, agent info
- 📊 **Structured output** — clean JSON/CSV/Excel ready for analysis
- ⚡ **API access** — integrate with Node.js, Python, or any HTTP client
- 📅 **Schedule runs** — monitor price changes daily, weekly, or monthly
- 🔗 **5,000+ integrations** — connect to Google Sheets, Slack, Zapier, Make, and more

### What data can you extract?

| Category | Fields |
|----------|--------|
| 📍 **Location** | address, city, state, ZIP code, latitude, longitude |
| 💵 **Pricing** | listing price, Zestimate, rent Zestimate, price history |
| 🏠 **Property** | bedrooms, bathrooms, living area (sqft), lot size, year built, property type |
| 📋 **Listing** | status (for sale/rent/sold), days on Zillow; page views and favorites count from property pages |
| 👤 **Agent** | broker name; agent name, agent phone and MLS ID from property pages |
| 💰 **Financials** | tax assessed value; annual property tax and monthly HOA fee from property pages |
| 📸 **Media** | photo URLs (all listing photos) |
| 🏫 **Schools** | nearby schools with ratings, distance, and grade levels (property pages) |

"From property pages" means the field is filled when you set `includeDetails: true` or pass `propertyUrls`. Rental buildings report the lowest unit rent as `price`. Rental building pages are not enriched by `includeDetails`, so their property-page fields stay empty.

### How much does it cost to scrape Zillow listings?

Zillow Scraper uses **pay-per-result** pricing. You only pay for listings you actually extract.

| Event | FREE plan | BRONZE | SILVER | GOLD | PLATINUM | DIAMOND |
|-------|-----------|--------|--------|------|----------|---------|
| Run started | $0.02 | $0.02 | $0.02 | $0.02 | $0.02 | $0.02 |
| Per listing | $0.008 | $0.007 | $0.0054 | $0.004 | $0.0028 | $0.002 |

**Example costs (FREE plan):**

- 10 listings from one city: ~$0.10
- 50 listings across 2 cities: ~$0.42
- 200 listings from multiple ZIP codes: ~$1.62

With the free $5 monthly credit on Apify's free plan, you can scrape **~600 listings per month** at no cost.

### How to scrape Zillow listings

1. Go to [Zillow Scraper](https://apify.com/automation-lab/zillow-scraper) on Apify Store
2. Enter a search query — city name (e.g., "Miami, FL"), ZIP code (e.g., "90210"), or full address
3. Set filters: listing type, price range, bedrooms, property type
4. Set the maximum number of listings to extract
5. Click **Start** and wait for results
6. Download your data as JSON, CSV, or Excel

**Example input — search by city:**

```json
{
    "searchQueries": ["San Francisco, CA"],
    "maxListings": 50,
    "listingType": "for_sale"
}
```

**Example input — search by ZIP code with filters:**

```json
{
    "searchQueries": ["90210"],
    "minBeds": 3,
    "minPrice": 500000,
    "maxPrice": 2000000,
    "maxListings": 25
}
```

**Example input — enrich every search result with property-page details:**

```json
{
    "searchQueries": ["Austin, TX"],
    "maxListings": 10,
    "includeDetails": true
}
```

Use `includeDetails` when you need fields such as `yearBuilt`, `zestimate`, `taxAssessedValue`, `priceHistory`, `schools`, agent details, or the full photo set. It follows each unique result's property URL, so enriched searches take longer and use more residential proxy traffic than the default search mode. If a detail page cannot be enriched, the actor still returns the base search row and records the URL in the `failed_urls` dataset. Rental building results (`/apartments/` pages, common in `for_rent` searches) are not enriched: they come back as search rows, are listed in `failed_urls`, and the run's status message says how many rows were not enriched.

**Example input — direct Zillow URLs:**

```json
{
    "propertyUrls": ["https://www.zillow.com/homedetails/15114736_zpid/"],
    "maxListings": 10
}
```

### Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| searchUrls | array | - | Zillow search page URLs to scrape |
| propertyUrls | array | - | Direct property detail page URLs |
| searchQueries | array | - | City names, ZIP codes, or addresses |
| listingType | string | for_sale | for_sale, for_rent or sold; `all` applies no listing-type filter (Zillow then shows homes for sale) |
| minPrice | integer | - | Minimum price filter (USD) |
| maxPrice | integer | - | Maximum price filter (USD) |
| minBeds | integer | - | Minimum bedrooms filter |
| minBaths | integer | - | Minimum bathrooms filter |
| propertyType | string | all | house (single-family), condo, townhouse, apartment, land, multi_family, manufactured |
| maxListings | integer | 100 | Maximum listings to extract (0 = all available, up to Zillow's 20 pages of about 41 listings per search; enrichment requires a positive limit) |
| includeDetails | boolean | false | Follow each unique search result to its detail page and merge rich fields; increases runtime and proxy use |
| maxRequestRetries | integer | 1 | Browser fallback retries after bounded HTTP-first attempts |

### Output example

```json
{
    "zpid": "95547747",
    "url": "https://www.zillow.com/homedetails/1261-Angelo-Dr-Beverly-Hills-CA-90210/95547747_zpid/",
    "address": "1261 Angelo Dr",
    "city": "Beverly Hills",
    "state": "CA",
    "zipcode": "90210",
    "price": 135000000,
    "currency": "USD",
    "homeStatus": "FOR_SALE",
    "propertyType": "SINGLE_FAMILY",
    "bedrooms": 16,
    "bathrooms": 27,
    "livingArea": 50000,
    "zestimate": null,
    "rentZestimate": 4183,
    "daysOnZillow": null,
    "brokerName": "Westside Estate Agency Inc.",
    "latitude": 34.09164,
    "longitude": -118.436676,
    "photos": [
        "https://photos.zillowstatic.com/fp/..."
    ],
    "priceHistory": [],
    "schools": [],
    "scrapedAt": "2026-03-17T22:03:31.000Z"
}
```

### Tips for best results

- 🏁 **Start small** — test with 5-10 listings first to verify the data matches your needs
- 🗺️ **Use specific locations** — "Miami Beach, FL" returns better results than just "Miami"
- 💰 **Use filters** — price, beds, baths, property type and listing type apply to search queries and to search URLs; filters already in a pasted Zillow URL are kept
- 🧭 **Large areas** — Zillow shows at most 20 pages (about 800 listings) per search, so split a big city into ZIP codes to get more
- 📝 **Status message** — every run ends with "Got N of M listings" and the reason it stopped
- 📅 **Schedule weekly runs** — track price changes over time by scheduling recurring scrapes
- 🔢 **ZIP codes work great** — entering a ZIP code gives highly targeted results
- 📊 **Export to Sheets** — connect the Apify Google Sheets integration for live property databases

### Integrations

- 📊 **Zillow Scraper → Google Sheets** — auto-populate a spreadsheet with new listings from your target ZIP codes for real-time market tracking
- 🔔 **Zillow Scraper → Slack** — get notified when new listings appear under your price threshold in specific neighborhoods
- ⚡ **Zillow Scraper → Make/Zapier** — trigger CRM updates or email alerts when properties matching your investment criteria hit the market
- 📅 **Scheduled monitoring** — run daily or weekly to track price drops, new listings, or days-on-market changes
- 🔗 **Webhooks** — process new listings in real-time as they're scraped for instant pipeline ingestion

### API Usage

**Node.js:**

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });
const run = await client.actor('automation-lab/zillow-scraper').call({
    searchQueries: ['Denver, CO'],
    maxListings: 50,
    listingType: 'for_sale',
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**Python:**

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_API_TOKEN')
run = client.actor('automation-lab/zillow-scraper').call(run_input={
    'searchQueries': ['Denver, CO'],
    'maxListings': 50,
    'listingType': 'for_sale',
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

**cURL:**

```bash
curl "https://api.apify.com/v2/acts/automation-lab~zillow-scraper/runs" \
  -X POST \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -d '{
    "searchQueries": ["Denver, CO"],
    "maxListings": 50,
    "listingType": "for_sale"
  }'
```

#### RSS feed export for property alerts

For scheduled property-listing alerts, create an Apify task and export the latest run as RSS with Apify's positional `outputFields` mapping. Because Zillow listings do not have a literal `title` field, this maps `address` to the RSS title:

```text
https://api.apify.com/v2/actor-tasks/{TASK_ID}/runs/last/dataset/items?format=rss&fields=address,url,homeStatus,scrapedAt&outputFields=title,link,description,pubDate&token=YOUR_API_TOKEN
```

### MCP and AI tool usage

Use Zillow Scraper through Apify's API, integrations, or MCP-compatible agent tooling to give AI assistants fresh real-estate data without building a custom Zillow crawler. Typical MCP workflows include asking an agent to collect listings for a city, compare rental prices by ZIP code, enrich a CRM with property details, or schedule recurring market checks that feed a spreadsheet or RAG pipeline.

Add the Apify MCP server to your AI client. The actor-scoped URL gives the agent this Actor as a tool:

#### Setup for Claude Code

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/zillow-scraper"
```

#### Setup for Claude Desktop, Cursor, or VS Code

Add this to your MCP config file:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com?tools=automation-lab/zillow-scraper"
        }
    }
}
```

Your AI assistant will use OAuth to authenticate with your Apify account on first use.

Example prompts:

- "Use Zillow Scraper to find 10 for-sale listings in Austin, TX under $900k and summarize the price, beds, baths, and listing URLs."
- "Run Zillow Scraper for San Francisco rental apartments with two or more bedrooms, then identify the three cheapest listings."
- "Extract details from these Zillow property URLs and prepare a CSV-ready comparison table."

When exposing this actor as a tool, keep the input bounded with `maxListings`, pass either specific `propertyUrls` or targeted `searchQueries`, and store the returned dataset URL so downstream agents can cite the exact records they used.

### Use this data in AI-agent and LLM workflows

This actor returns structured JSON that can be called from the Apify API, scheduled runs, webhooks, or integrations such as Make and Zapier. Use it to feed property-search agents, market-monitoring agents, valuation/RAG pipelines, CRM enrichment, or daily alerts without maintaining your own scraper.

For multi-source coverage, combine:

- [Zillow Scraper](https://apify.com/automation-lab/zillow-scraper) for Zillow search/detail data and Zestimates
- [Redfin Scraper](https://apify.com/automation-lab/redfin-scraper) for fast Redfin listing data
- [Realtor.com Scraper](https://apify.com/automation-lab/realtor-scraper) for for-sale, rental, and recently sold coverage
- [Realtor.com Agents Scraper](https://apify.com/automation-lab/realtor-agents-scraper) for active agent/contact enrichment

Useful search terms: real estate data API, property listings API, Zillow API alternative, Redfin API alternative, Realtor.com API alternative, housing market data, AI agent real estate data, property data for LLM, real estate scraper, property scraper.

### Is it legal to scrape Zillow?

Zillow Scraper only accesses publicly available data on Zillow.com — the same information visible to any visitor without logging in. Web scraping of public data is generally legal, as supported by the US Ninth Circuit ruling in *HiQ Labs v. LinkedIn*.

You should always:

- Comply with Zillow's Terms of Service
- Respect rate limits and avoid overloading servers
- Handle personal data (agent contacts) in accordance with GDPR and applicable privacy laws
- Use the data responsibly and ethically

### Legality

Scraping publicly available data is generally legal according to the [US Court of Appeals ruling](https://en.wikipedia.org/wiki/HiQ_Labs_v._LinkedIn) (HiQ Labs v. LinkedIn). This actor only accesses publicly available information and does not require authentication. Always review and comply with the target website's Terms of Service before scraping. For personal data, ensure compliance with GDPR, CCPA, and other applicable privacy regulations.

### FAQ

**How fast is Zillow Scraper?**
A typical search returns 10-40 listings in 30-90 seconds. The scraper uses PlaywrightCrawler with residential proxy and browser fingerprinting to reliably bypass Zillow's anti-bot protections.

**How much does it cost to scrape 100 Zillow listings?**
On the FREE plan: $0.02 (start) + 100 × $0.008 = **$0.82**. On BRONZE: **$0.72**. On GOLD: **$0.42**.

**Why are some fields null?**
Search result pages return fewer fields than detail pages. For city, ZIP, or search-URL inputs, set `includeDetails` to `true` to follow each unique result and merge fields such as `yearBuilt`, `description`, `priceHistory`, `schools`, and `taxAssessedValue`. Direct `propertyUrls` already use detail extraction. Zillow does not expose every field for every property, and a blocked enrichment falls back to the usable base search row while recording its URL in `failed_urls`.

**Why did my run return 0 results?**
This usually means Zillow's anti-bot protection blocked the request. Try again — the scraper uses session rotation and retries automatically. If the issue persists, the search query might not match any Zillow location.

**Does it work for rentals and sold properties?**
Yes — set `listingType` to `for_rent` or `sold` to search those categories.

### How do you monitor Zillow for new listings in a specific ZIP code?

Use scheduled runs combined with the `listingType` filter:

1. Set `searchQueries` to your target ZIP code (e.g., `"90210"`) and `listingType` to `for_sale`.
2. Schedule a daily run in Apify Console.
3. Sort results by `daysOnZillow` ascending — listings with 0–1 days on market are newest.
4. Connect a webhook to Slack or email so you're alerted the moment new listings hit.
5. For investment criteria matching, add filters like `minBeds`, `maxPrice`, and `propertyType` to avoid noise.

This workflow replaces manual Zillow browsing and ensures you see properties within hours of them going live — before most buyers.

### What is the Zillow Zestimate and how reliable is it?

The **Zestimate** is Zillow's automated property valuation model (AVM). It uses public records, MLS data, tax assessments, and comparable sales to estimate a property's market value. According to Zillow's own accuracy data, the median error rate for on-market homes is around 2–3%, but can be significantly higher (10–20%+) for off-market properties or homes in rural areas with sparse sales data.

In the scraper output, the `zestimate` field contains the current estimated value, and `rentZestimate` provides Zillow's estimate of monthly rental income. For properties where Zillow has limited data (e.g., new construction, unusual properties), `zestimate` may be `null`. Use it as a starting point for analysis, not a definitive valuation.

### How do you build a real estate comparable sales database from Zillow?

1. Set `listingType` to `sold` in the input to fetch recently sold properties.
2. Search by ZIP code or city to scope the comps geographically.
3. Filter by `propertyType` (e.g., `house`) and bedroom/bathroom count to match your subject property.
4. Export to Google Sheets or CSV and sort by `price` to see the sale price range.
5. Use `livingArea` to calculate price-per-sqft for each comp.
6. Schedule monthly runs to keep your comps database fresh.

Key fields for comp analysis: `price`, `livingArea`, `bedrooms`, `bathrooms`, `yearBuilt`, `daysOnZillow`, `taxAssessedValue`, and `priceHistory`. Set `includeDetails` to `true` on the search to merge full property-page fields, including `priceHistory` and `schools`, into each search row.

### How do you track Zillow price drops in a neighborhood?

1. Run the scraper for your target area weekly and save each run's dataset.
2. Join datasets by `zpid` (Zillow's unique property ID) across time.
3. Compare `price` values between runs — a lower price on the same `zpid` indicates a price reduction.
4. Properties with multiple price drops and rising `daysOnZillow` signal motivated sellers.

Alternatively, use the `priceHistory` field (available on detail pages) which contains the full price change log directly from Zillow, including the date and amount of each reduction.

### Does Zillow Scraper work for rental listings?

Yes. Set `listingType` to `for_rent` in the input. The scraper returns rental listings with price (monthly rent), bedrooms, bathrooms, square footage, and agent contact info. The `rentZestimate` field on for-sale listings also provides Zillow's estimate of potential rental income, which is useful for buy-to-let investment analysis.

For rental market research, combine `for_rent` searches across multiple ZIP codes to map median rents by area and property type.

### Build a production real-estate data workflow

Use this actor as one source in a repeatable property-data pipeline: scrape listings from the source site, export structured JSON/CSV/Excel, schedule refreshes, and send results to your dashboard, CRM, warehouse, or AI/LLM workflow.

Use Zillow as the US-market baseline in your property data workflow: collect price, Zestimate, beds/baths, sqft, tax records, photos, schools, and price history, then export or schedule results for market dashboards, investor comps, alerts, and AI/RAG pipelines.

For broader coverage, combine it with related Automation Lab actors:

- US residential listings: [Zillow Scraper](https://apify.com/automation-lab/zillow-scraper), [Redfin Scraper](https://apify.com/automation-lab/redfin-scraper), [Realtor.com Scraper](https://apify.com/automation-lab/realtor-scraper)
- US agent lead data: [Realtor.com Agents Scraper](https://apify.com/automation-lab/realtor-agents-scraper)
- UK and Europe: [Rightmove Scraper](https://apify.com/automation-lab/rightmove-scraper), [ImmoScout24 Germany Real Estate Scraper](https://apify.com/automation-lab/immoscout24-de-scraper), [Imovirtual Scraper](https://apify.com/automation-lab/imovirtual-scraper), [RE/MAX Portugal Scraper](https://apify.com/automation-lab/remax-portugal-scraper), [Sreality.cz Real Estate Scraper](https://apify.com/automation-lab/sreality-cz-real-estate-scraper), [Pisos.com Real Estate Scraper](https://apify.com/automation-lab/pisos-com-real-estate-scraper)
- Middle East / South Asia: [PropertyFinder Scraper](https://apify.com/automation-lab/propertyfinder-scraper), [Zameen Property Scraper](https://apify.com/automation-lab/zameen-property-scraper)
- Short-term rentals: [Airbnb Scraper](https://apify.com/automation-lab/airbnb-listing) and [Airbnb Reviews Scraper](https://apify.com/automation-lab/airbnb-reviews)

### Related real-estate actors

- [Zillow Scraper](https://apify.com/automation-lab/zillow-scraper) — Zillow search/detail data, property attributes, photos, and Zestimates
- [Redfin Scraper](https://apify.com/automation-lab/redfin-scraper) — fast Redfin listing data for cities, ZIP codes, neighborhoods, and counties
- [Realtor.com Scraper](https://apify.com/automation-lab/realtor-scraper) — Realtor.com for-sale, rental, and recently sold listings
- [Realtor.com Agents Scraper](https://apify.com/automation-lab/realtor-agents-scraper) — active real-estate agent contacts and brokerage enrichment

### Use with AI agents via x402 (no Apify account)

Agent workflows can run this actor through Apify MCP without an Apify account when the MCP client uses a funded x402 wallet. Use the actor-specific MCP endpoint:

`https://mcp.apify.com?tools=automation-lab/zillow-scraper&payment=x402`

This keeps existing Apify MCP/API usage unchanged; x402 only changes payment/authentication for clients that support it. Learn more in Apify's [x402 integration docs](https://docs.apify.com/platform/integrations/x402).

### Diagnostic privacy

Failed operations send sanitized diagnostic input, exceptions, and Actor/build/run IDs to our private GlitchTip service for repair. Secret fields and URL query strings are removed; reports are retained for 30 days.

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/zillow-scraper/changelog.md

# Actor input Schema

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

Zillow search URLs to scrape. Copy any search URL from Zillow (e.g., https://www.zillow.com/san-francisco-ca/).

## `propertyUrls` (type: `array`):

Direct Zillow property page URLs (e.g., https://www.zillow.com/homedetails/...).

## `searchQueries` (type: `array`):

Text search queries — city names, ZIP codes, or addresses (e.g., 'San Francisco, CA' or '94102').

## `listingType` (type: `string`):

Type of listings to search for: homes for sale, rentals, or recently sold homes. 'all' applies no listing-type filter, which shows Zillow's default (homes for sale). Applies to search queries and search URLs.

## `minPrice` (type: `integer`):

Minimum listing price in USD.

## `maxPrice` (type: `integer`):

Maximum listing price in USD.

## `minBeds` (type: `integer`):

Minimum number of bedrooms.

## `minBaths` (type: `integer`):

Minimum number of bathrooms.

## `propertyType` (type: `string`):

Keep only one property type. 'house' means single-family homes. Applies to search queries and search URLs.

## `maxListings` (type: `integer`):

Maximum number of listings to scrape. Set 0 for unlimited.

## `includeDetails` (type: `boolean`):

For each unique search result, fetch its property page and merge richer fields such as year built, Zestimates, tax data, price history, schools, agent details, and additional photos. This is opt-in because it increases runtime and residential proxy usage. If enrichment fails, the base search row is still returned and the URL is recorded in failed_urls.

## `maxRequestRetries` (type: `integer`):

Number of retry attempts for failed requests in the Playwright browser phase. Higher values improve success rate against Zillow's anti-bot protection at the cost of more proxy usage. The HTTP-first phase uses a bounded set of fresh proxy identities before the browser starts.

## Actor input object example

```json
{
  "searchUrls": [
    "https://www.zillow.com/san-francisco-ca/"
  ],
  "listingType": "for_sale",
  "propertyType": "all",
  "maxListings": 10,
  "includeDetails": false,
  "maxRequestRetries": 1
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 = {
    "searchUrls": [
        "https://www.zillow.com/san-francisco-ca/"
    ],
    "maxListings": 10,
    "includeDetails": false,
    "maxRequestRetries": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/zillow-scraper").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 = {
    "searchUrls": ["https://www.zillow.com/san-francisco-ca/"],
    "maxListings": 10,
    "includeDetails": False,
    "maxRequestRetries": 1,
}

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

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

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

```

## CLI example

```bash
echo '{
  "searchUrls": [
    "https://www.zillow.com/san-francisco-ca/"
  ],
  "maxListings": 10,
  "includeDetails": false,
  "maxRequestRetries": 1
}' |
apify call automation-lab/zillow-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/zillow-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/wvNDBegPs5c9Vykyb/builds/geLTml4D7D3er226I/openapi.json