# Zillow Scraper 🏷️ (`parseforge/zillow-scraper`) Actor

Scrape Zillow.com property listings and detail pages to extract comprehensive real estate data: prices, contact, bedrooms, bathrooms, square footage, images, agent information, location, and fees. Lightning-fast API-based scraping with 100% accuracy for investors, agents, and market researchers.

- **URL**: https://apify.com/parseforge/zillow-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Real estate, Automation, Developer tools
- **Stats:** 73 total users, 4 monthly users, 98.9% runs succeeded, 4 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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🏠 Zillow Scraper

> 🚀 **Collect property listings from Zillow.com in minutes.** Filter by location, price, bedrooms, bathrooms, square footage, lot size, and year built. Export full property data, Zestimates, agent info, and photos. No coding, no Zillow API key.

> 🕒 **Last updated:** 2026-04-23 · **📊 20+ fields** per property · **🔍 8 search filters** · **📸 Photo galleries** · **🚫 No auth** required

The **Zillow Scraper** collects residential property listing data from Zillow.com, returning **20+ fields per property**: address, price, Zestimate, price per square foot, bedrooms, bathrooms, square footage, lot size, year built, property type, listing agent, photos, coordinates, and direct URL. Runs support up to 1,000,000 properties on a paid plan.

The Actor supports two input modes: direct Zillow URLs and search-filter mode. Filters include location (city, state, ZIP), price range, bedrooms, bathrooms, square footage range, lot size, year built, and sort order. Paste any Zillow search URL or let the filters build the query for you.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Real estate investors, agents, brokers, appraisers, market analysts, data scientists, property managers | Market research, investment analysis, comp building, lead generation, portfolio monitoring, pricing strategy |

---

### 📋 What the Zillow Scraper does

Two input modes with eight filters:

- 🔗 **URL mode.** Paste any Zillow search or listing URL. All filter parameters are extracted automatically.
- 📍 **Search filter mode.** Enter a location (city, state, or ZIP) and apply price, bedroom, bathroom, sqft, lot size, and year-built filters.
- 📊 **Sort options.** Sort results by price, newest, most bedrooms, square footage, or lot size.

Each property record includes address, city, state, ZIP, price, Zestimate, price per sqft, bedrooms, bathrooms, square footage, lot size, year built, property type, listing agent name and company, primary image URL, photo gallery, latitude/longitude, and property URL.

> 💡 **Why it matters:** tracking property listings manually means scrolling through Zillow pages, copying data into spreadsheets, and refreshing daily for new listings. This Actor exports structured property data at scale, ready for your investment models, CRM, or market dashboards.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded dataset._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td>startUrl</td><td>string</td><td>""</td><td>Direct Zillow URL. If set, all other filters are ignored.</td></tr>
<tr><td>location</td><td>string</td><td>""</td><td>City, state, ZIP, or area (e.g. "Los Angeles, CA").</td></tr>
<tr><td>priceMin</td><td>integer</td><td>-</td><td>Minimum price in USD.</td></tr>
<tr><td>priceMax</td><td>integer</td><td>-</td><td>Maximum price in USD.</td></tr>
<tr><td>bedrooms</td><td>integer</td><td>-</td><td>Minimum number of bedrooms.</td></tr>
<tr><td>bathrooms</td><td>number</td><td>-</td><td>Minimum number of bathrooms.</td></tr>
<tr><td>squareFeetMin / squareFeetMax</td><td>integer</td><td>-</td><td>Square footage range.</td></tr>
<tr><td>lotSizeMin</td><td>number</td><td>-</td><td>Minimum lot size in acres.</td></tr>
<tr><td>yearBuiltMin</td><td>integer</td><td>-</td><td>Minimum year built.</td></tr>
<tr><td>sortBy</td><td>string</td><td>""</td><td>Sort: price, newest, bedrooms, sqft, or lot size.</td></tr>
<tr><td>maxItems</td><td>integer</td><td>10</td><td>Max properties. Paid: up to 1,000,000.</td></tr>
</tbody>
</table>

**Example: homes in Los Angeles, $500K-$1M, 3+ bedrooms.**

```json
{
    "location": "Los Angeles, CA",
    "priceMin": 500000,
    "priceMax": 1000000,
    "bedrooms": 3,
    "maxItems": 50
}
````

**Example: scrape a specific Zillow search URL.**

```json
{
    "startUrl": "https://www.zillow.com/los-angeles-ca/rentals/",
    "maxItems": 100
}
```

> ⚠️ **Good to Know:** you can apply filters on Zillow's website (price, beds, baths, home type, etc.), then copy the URL and paste it as `startUrl`. The Actor respects all parameters embedded in the URL.

***

### 📊 Output

Each property record contains **20+ fields**. Download the dataset as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🖼️ `imageUrl` | string | `"https://photos.zillowstatic.com/..."` |
| 🏠 `address` | string | `"123 Palm Ave"` |
| 🏙️ `city` | string | `"Los Angeles"` |
| 🏳️ `state` | string | `"CA"` |
| 📮 `zipCode` | string | `"90001"` |
| 💰 `price` | number | `750000` |
| 📊 `zestimate` | number | null | `725000` |
| 💵 `pricePerSqFt` | number | null | `450` |
| 🛏️ `bedrooms` | number | `3` |
| 🛁 `bathrooms` | number | `2` |
| 📏 `squareFeet` | number | `1650` |
| 📐 `lotSize` | string | `"0.15 acres"` |
| 📅 `yearBuilt` | number | `1965` |
| 🏷️ `propertyType` | string | `"Single Family"` |
| 👤 `listingAgent` | string | `"Jane Smith"` |
| 🏢 `agentCompany` | string | `"RE/MAX"` |
| 🖼️ `photos` | array | `["https://photos.zillowstatic.com/..."]` |
| 📍 `latitude` | number | `34.0522` |
| 📍 `longitude` | number | `-118.2437` |
| 🔗 `url` | string | `"https://www.zillow.com/homedetails/..."` |
| 🕒 `scrapedAt` | ISO 8601 | `"2026-04-16T00:00:00.000Z"` |

#### 📦 Sample records

<details>
<summary><strong>🏠 Single family home with full data</strong></summary>

```json
{
    "imageUrl": "https://photos.zillowstatic.com/example1.jpg",
    "address": "123 Palm Ave",
    "city": "Los Angeles",
    "state": "CA",
    "zipCode": "90001",
    "price": 750000,
    "zestimate": 725000,
    "pricePerSqFt": 454,
    "bedrooms": 3,
    "bathrooms": 2,
    "squareFeet": 1650,
    "lotSize": "0.15 acres",
    "yearBuilt": 1965,
    "propertyType": "Single Family",
    "listingAgent": "Jane Smith",
    "agentCompany": "RE/MAX",
    "photos": ["https://photos.zillowstatic.com/example1.jpg"],
    "latitude": 34.0522,
    "longitude": -118.2437,
    "url": "https://www.zillow.com/homedetails/123-palm-ave/12345_zpid/",
    "scrapedAt": "2026-04-16T00:00:00.000Z"
}
```

</details>

<details>
<summary><strong>🏢 Condo with Zestimate data</strong></summary>

```json
{
    "imageUrl": "https://photos.zillowstatic.com/condo.jpg",
    "address": "456 Ocean Blvd Unit 8C",
    "city": "Miami",
    "state": "FL",
    "zipCode": "33139",
    "price": 420000,
    "zestimate": 415000,
    "pricePerSqFt": 525,
    "bedrooms": 2,
    "bathrooms": 2,
    "squareFeet": 800,
    "lotSize": null,
    "yearBuilt": 2012,
    "propertyType": "Condo",
    "listingAgent": "Carlos Reyes",
    "agentCompany": "Keller Williams",
    "photos": ["https://photos.zillowstatic.com/condo.jpg"],
    "latitude": 25.7617,
    "longitude": -80.1918,
    "url": "https://www.zillow.com/homedetails/456-ocean-blvd/67890_zpid/",
    "scrapedAt": "2026-04-16T00:00:00.000Z"
}
```

</details>

<details>
<summary><strong>🏡 Rural property with sparse data</strong></summary>

```json
{
    "imageUrl": null,
    "address": "County Rd 12",
    "city": "Rural Town",
    "state": "TX",
    "zipCode": "79001",
    "price": 125000,
    "zestimate": null,
    "pricePerSqFt": null,
    "bedrooms": 2,
    "bathrooms": 1,
    "squareFeet": null,
    "lotSize": "10 acres",
    "yearBuilt": null,
    "propertyType": "Single Family",
    "listingAgent": null,
    "agentCompany": null,
    "photos": [],
    "latitude": 34.5,
    "longitude": -101.3,
    "url": "https://www.zillow.com/homedetails/county-rd-12/11111_zpid/",
    "scrapedAt": "2026-04-16T00:00:00.000Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🏠 | **Full property data.** Price, Zestimate, price/sqft, specs, agent, photos, and coordinates. |
| 🔍 | **Eight search filters.** Location, price range, beds, baths, sqft, lot size, year built, and sort. |
| 🔗 | **Two input modes.** Direct Zillow URLs or search-filter mode. |
| 📸 | **Photo galleries.** Primary image plus full gallery per property. |
| 📍 | **Coordinates.** Latitude and longitude for mapping and proximity analysis. |
| ⚡ | **Scalable.** From quick 10-listing checks to full market sweeps. |
| 🚫 | **No authentication.** No Zillow API key or developer account needed. |

> 📊 Zillow processes over 200 million monthly unique users. Structured access to listing data is the foundation for any real estate investment, pricing, or market analysis workflow.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ Zillow Scraper** *(this Actor)* | $5 free credit, then pay-per-use | Any Zillow market | **Live per run** | location, price, beds, baths, sqft, lot, year | ⚡ 2 min |
| Zillow API (Bridge API) | Paid, enterprise | Full MLS | Real-time | Many | 🐢 Weeks (application) |
| Paid real estate data platforms | $299-999/month | Multi-source | Varies | Many | ⏳ Days |
| Manual Zillow browsing | Free | Manual | Manual | Zillow UI only | 🕒 Hours per market |

Pick this Actor when you want Zillow data on demand, without an enterprise API contract, without building a custom pipeline, and without paying for a full real estate data subscription.

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Go to the Zillow Scraper page on the Apify Store.
3. 🎯 **Set input.** Enter a location or paste a Zillow URL. Set price range, beds, baths, and `maxItems`.
4. 🚀 **Run it.** Click **Start** and let the Actor collect your data.
5. 📥 **Download.** Grab your results in the **Dataset** tab as CSV, Excel, JSON, or XML.

> ⏱️ Total time from signup to downloaded dataset: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%" valign="top">

#### 💰 Real Estate Investors

- Scan markets for undervalued properties
- Compare listing price vs Zestimate for opportunity detection
- Track inventory changes in target ZIP codes
- Build comp sets for investment decisions

</td>
<td width="50%" valign="top">

#### 🏢 Agents & Brokers

- Monitor new listings in your farm area daily
- Track competitor agent listing activity
- Build lead lists from expired or price-reduced listings
- Generate market reports for buyer consultations

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### 📊 Market Analysts & Researchers

- Track median prices and inventory trends by ZIP
- Analyze price-per-sqft across neighborhoods
- Study seasonal listing patterns
- Build longitudinal pricing databases

</td>
<td width="50%" valign="top">

#### 🏦 Lenders & Appraisers

- Pull comps for property valuation
- Monitor price trends in lending areas
- Track days-on-market by property type
- Build automated market condition reports

</td>
</tr>
</table>

***

### 🌟 Beyond business use cases

Data like this powers more than commercial workflows. The same structured records support research, education, civic projects, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Empirical datasets for papers, thesis work, and coursework
- Longitudinal studies tracking changes across snapshots
- Reproducible research with cited, versioned data pulls
- Classroom exercises on data analysis and ethical scraping

</td>
<td width="50%">

#### 🎨 Personal and creative

- Side projects, portfolio demos, and indie app launches
- Data visualizations, dashboards, and infographics
- Content research for bloggers, YouTubers, and podcasters
- Hobbyist collections and personal trackers

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Transparency reporting and accountability projects
- Advocacy campaigns backed by public-interest data
- Community-run databases for local issues
- Investigative journalism on public records

</td>
<td width="50%">

#### 🧪 Experimentation

- Prototype AI and machine-learning pipelines with real data
- Validate product-market hypotheses before engineering spend
- Train small domain-specific models on niche corpora
- Test dashboard concepts with live input

</td>
</tr>
</table>

***

### 🔌 Automating Zillow Scraper

Control the scraper programmatically for scheduled runs and pipeline integrations:

- 🟢 **Node.js.** Install the `apify-client` NPM package.
- 🐍 **Python.** Use the `apify-client` PyPI package.
- 📚 See the [Apify API documentation](https://docs.apify.com/api/v2) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor on any cron interval. Daily pulls keep your real estate monitoring dashboard in sync automatically.

***

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt about this ParseForge actor in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20Zillow%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20Zillow%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20Zillow%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20Zillow%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

***

### ❓ Frequently Asked Questions

#### 🧩 How does it work?

Configure your location and filters in the input form (or paste a Zillow URL), click Start, and the Actor collects property data from Zillow's listing pages, applies your filters, and returns one structured record per property.

#### 📏 How accurate is the data?

The data is collected from Zillow's public listing pages. Prices, Zestimates, and availability reflect the state at the time of the run. Zillow updates listings in real time, so each run captures a point-in-time snapshot.

#### 🏠 Does it include rental listings?

Yes. Paste a Zillow rentals URL (e.g. `zillow.com/los-angeles-ca/rentals/`) as `startUrl` to collect rental listings.

#### ⏰ Can I schedule regular runs?

Yes. Use Apify Schedules to run this Actor daily or weekly and keep your property database in sync.

#### ⚖️ Is this data legal to use?

This Actor collects publicly listed property data from Zillow.com. Review Zillow's terms of service for your specific downstream use case.

#### 💼 Can I use this data commercially?

Yes, for analytics, research, and internal dashboards. For republication of Zillow listing content, review Zillow's terms of service.

#### 💳 Do I need a paid Apify plan?

No. The free Apify plan with $5 credit is enough for testing. A paid plan lifts the item limit and gives you scheduling and higher concurrency.

#### 🔁 What happens if a run fails?

Apify automatically retries transient errors. If a run still fails, inspect the log in the Runs tab, fix the input, and re-run. Partial datasets are preserved.

#### 🆘 What if I need help?

Our support team is here to help. Contact us through the Apify platform or use the Tally form linked below.

***

### 🔌 Integrate with any app

Zillow Scraper connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Get alerts when new listings match your criteria
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe property data into your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from commits and releases
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export datasets straight to Sheets

You can also use webhooks to trigger downstream actions when a run finishes. Push fresh listings into your CRM, or alert your team in Slack.

***

### 🔗 Recommended Actors

- [**🏠 Auction.com Property Scraper**](https://apify.com/parseforge/auction-com-property-scraper) - Real estate auction listings and bids
- [**🏢 Commercial Real Estate Scraper**](https://apify.com/parseforge/commercial-real-estate-listings-scraper) - Commercial property listings from Crexi
- [**🏠 Apartments.com Scraper**](https://apify.com/parseforge/apartments-com-scraper) - Rental property listings
- [**🏡 James Edition Real Estate Scraper**](https://apify.com/parseforge/james-edition-real-estate-scraper) - Luxury real estate listings worldwide
- [**📊 Indexmundi Scraper**](https://apify.com/parseforge/indexmundi-scraper) - Global demographic and economic indicators

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more real estate scrapers.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper, propose a custom data project, or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Zillow Group, Inc. or any of its subsidiaries. All trademarks mentioned are the property of their respective owners. Only publicly available listing data is collected.

# Actor input Schema

## `listingUrl` (type: `string`):

Zillow listing/search page URL to scrape. Should include searchQueryState query parameter for best results. Mutually exclusive with detailsUrl. When using listingUrl, maxItems will limit the number of results.

## `maxItems` (type: `integer`):

Maximum items (Free users: Limited to 100. Paid users: Optional, max 1,000,000)

## `detailsUrl` (type: `array`):

Array of Zillow property detail page URLs to scrape. Mutually exclusive with listingUrl. When using detailsUrl, maxItems is ignored and all provided URLs will be scraped.

## `proxyConfig` (type: `object`):

Configure proxy settings for the scraper

## Actor input object example

```json
{
  "listingUrl": "https://www.zillow.com/new-york-ny/",
  "maxItems": 10,
  "detailsUrl": [],
  "proxyConfig": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

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

Overview view of properties with key fields displayed in a table format

## `properties` (type: `string`):

Complete dataset with all scraped Zillow property data including property details, pricing, specifications, agent information, location data, and images

# 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 = {
    "listingUrl": "https://www.zillow.com/new-york-ny/",
    "maxItems": 10,
    "detailsUrl": [],
    "proxyConfig": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/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 = {
    "listingUrl": "https://www.zillow.com/new-york-ny/",
    "maxItems": 10,
    "detailsUrl": [],
    "proxyConfig": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/zillow-scraper").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 '{
  "listingUrl": "https://www.zillow.com/new-york-ny/",
  "maxItems": 10,
  "detailsUrl": [],
  "proxyConfig": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call parseforge/zillow-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Zillow Scraper 🏷️",
        "description": "Scrape Zillow.com property listings and detail pages to extract comprehensive real estate data: prices, contact, bedrooms, bathrooms, square footage, images, agent information, location, and fees. Lightning-fast API-based scraping with 100% accuracy for investors, agents, and market researchers.",
        "version": "1.0",
        "x-build-id": "q6i5zBifgGeWCeWhl"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~zillow-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-zillow-scraper",
                "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/parseforge~zillow-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-zillow-scraper",
                "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/parseforge~zillow-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-zillow-scraper",
                "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": {
                    "listingUrl": {
                        "title": "Listing URL",
                        "type": "string",
                        "description": "Zillow listing/search page URL to scrape. Should include searchQueryState query parameter for best results. Mutually exclusive with detailsUrl. When using listingUrl, maxItems will limit the number of results."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Maximum items (Free users: Limited to 100. Paid users: Optional, max 1,000,000)"
                    },
                    "detailsUrl": {
                        "title": "Detail URLs",
                        "type": "array",
                        "description": "Array of Zillow property detail page URLs to scrape. Mutually exclusive with listingUrl. When using detailsUrl, maxItems is ignored and all provided URLs will be scraped.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "proxyConfig": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Configure proxy settings for the scraper"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```