# Zillow Property Listings Scraper (`fetch_cat/zillow-property-listings-scraper`) Actor

Scrape public Zillow sale, rent, and sold property search results with prices, addresses, beds, baths, brokers, images, and map coordinates.

- **URL**: https://apify.com/fetch\_cat/zillow-property-listings-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.07 / 1,000 item extracteds

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 Property Listings Scraper

Scrape public Zillow property search results and export structured sale, rental, or recently sold listings to CSV, JSON, Excel, or the Apify API.

Use it to monitor housing inventory, collect comparable properties, enrich market research, build relocation shortlists, or track public listing changes by city or Zillow search URL.

### Who is it for?

- **Real-estate investors** tracking prices, inventory, and comparable homes.
- **Agents and brokerages** monitoring public listings in target markets.
- **Proptech and data teams** building internal dashboards from public property search results.
- **Relocation teams** creating shortlists across multiple cities.
- **Market researchers** comparing public sale and rental inventory over time.

### Example input

```json
{
  "locations": ["San Francisco, CA"],
  "listingType": "for_sale",
  "maxItems": 25,
  "maxPages": 1,
  "proxy": { "useApifyProxy": true }
}
````

You can also paste Zillow search result URLs directly:

```json
{
  "startUrls": [
    { "url": "https://www.zillow.com/homes/for_rent/Austin,-TX_rb/" }
  ],
  "maxItems": 50,
  "maxPages": 2
}
```

### Output example

```json
{
  "zpid": "12345678",
  "url": "https://www.zillow.com/homedetails/12345678_zpid/",
  "address": "123 Market St, San Francisco, CA 94103",
  "price": "$1,250,000",
  "unformattedPrice": 1250000,
  "currency": "USD",
  "beds": 3,
  "baths": 2,
  "area": 1450,
  "propertyType": "SINGLE_FAMILY",
  "homeStatus": "FOR_SALE",
  "latitude": 37.7749,
  "longitude": -122.4194,
  "brokerName": "Example Realty",
  "imageUrl": "https://photos.zillowstatic.com/...jpg",
  "daysOnZillow": 12,
  "isFeatured": false,
  "listingType": "for_sale",
  "sourceUrl": "https://www.zillow.com/homes/for_sale/San-Francisco,-CA_rb/",
  "scrapedAt": "2026-07-08T08:00:00.000Z"
}
```

### Input settings

| Field | Type | Description |
| --- | --- | --- |
| `startUrls` | array | Public Zillow search result URLs to scrape. |
| `locations` | array | City or area names. The actor creates Zillow search URLs from them. |
| `listingType` | string | `for_sale`, `for_rent`, or `sold` for generated location searches. |
| `maxItems` | integer | Maximum unique listings to save. |
| `maxPages` | integer | Maximum result pages to request per search source. |
| `proxy` | object | Apify Proxy settings. Recommended for Zillow because blocks can occur. |

### Output fields

The dataset includes listing identity, URL, address, formatted and raw price, currency, beds, baths, living area, property type, home status, latitude, longitude, broker name, image URL, days on Zillow, featured flag, source URL, listing type, and scrape timestamp.

### Pricing

This actor uses pay-per-event pricing:

- Start: $0.005 per run
- Property listing saved: tiered from $0.00012508 to $0.000030455 per listing, with the Bronze tier at $0.00010877 per listing.

At the Bronze tier, 1,000 saved listings cost about $0.11 plus the run start fee.

### Tips and limits

- Start with a small `maxItems` value for your first run.
- Zillow can block automated requests. Keep `maxPages` conservative and use Apify Proxy.
- Only public listing/search data is extracted. The actor does not access private accounts, messages, saved homes, or owner-only data.
- If Zillow returns a CAPTCHA/block page, the run stops with a clear error rather than producing empty rows.

### API usage

Run the actor from cURL:

```bash
curl "https://api.apify.com/v2/acts/fetch_cat~zillow-property-listings-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"locations":["San Francisco, CA"],"listingType":"for_sale","maxItems":20}'
```

Run it from Node.js:

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/zillow-property-listings-scraper').call({
  locations: ['San Francisco, CA'],
  listingType: 'for_sale',
  maxItems: 20,
});
console.log(run.defaultDatasetId);
```

Run it from Python:

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/zillow-property-listings-scraper').call(run_input={
    'locations': ['San Francisco, CA'],
    'listingType': 'for_sale',
    'maxItems': 20,
})
print(run['defaultDatasetId'])
```

### MCP and agents

Use this actor from Apify MCP-compatible agents with:

```text
https://mcp.apify.com/?tools=fetch_cat/zillow-property-listings-scraper
```

Add it to Claude Desktop or Claude Code with a command like:

```bash
claude mcp add apify-zillow --url "https://mcp.apify.com/?tools=fetch_cat/zillow-property-listings-scraper"
```

Example MCP server JSON config:

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

Example prompts:

- "Scrape up to 20 Zillow for-sale listings in San Francisco and summarize median price."
- "Collect rental listings for Austin and return address, price, beds, baths, and URL."
- "Compare public Zillow inventory for Denver and San Francisco using this actor."

### Legality and responsible use

This actor extracts public listing/search information that is visible without logging in. Do not use it to collect private account data, bypass paywalls, or violate applicable laws or website terms. Keep request volume reasonable, use the built-in limits, and store only the data you are allowed to process.

### FAQ

**Does this actor need a Zillow account?**
No. It is designed for public search result pages only.

**Can it scrape rentals and sold properties?**
Yes. Use `listingType` for location inputs or paste matching Zillow search URLs in `startUrls`.

**Why did my run stop with a block message?**
Zillow may block automated traffic. Lower `maxPages`, keep concurrency low, and use Apify residential proxy settings.

**Can I use exact Zillow filter URLs?**
Yes. Paste the filtered public Zillow search URL into `startUrls`.

**Does it scrape property detail pages?**
The first version focuses on search-result listing data. Detail-page enrichment can be added later if demand and reliability justify it.

### Related actors

- [Google Maps Scraper](https://apify.com/fetch_cat/google-maps-scraper)
- [Google Search Results Scraper](https://apify.com/fetch_cat/google-search-results-scraper)

### Support

If you need help, share your run ID or run URL, input JSON, expected output, and actual output so we can reproduce the issue.

### Changelog

- 2026-07-08: Initial version for public Zillow property search listings.

# Actor input Schema

## `startUrls` (type: `array`):

One or more public Zillow search result URLs, such as city sale or rental searches.

## `locations` (type: `array`):

Optional city or area names. The actor converts each location into a Zillow search URL using the selected listing type.

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

Used when generating Zillow search URLs from locations. Start URLs keep their own listing type.

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

Maximum number of unique Zillow listings to save.

## `maxPages` (type: `integer`):

How many Zillow result pages to request for each search source.

## `proxy` (type: `object`):

Apify Proxy is recommended because Zillow can block datacenter traffic.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.zillow.com/homes/for_sale/San-Francisco,-CA_rb/"
    }
  ],
  "locations": [
    "San Francisco, CA"
  ],
  "listingType": "for_sale",
  "maxItems": 20,
  "maxPages": 1,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# 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 = {
    "startUrls": [
        {
            "url": "https://www.zillow.com/homes/for_sale/San-Francisco,-CA_rb/"
        }
    ],
    "locations": [
        "San Francisco, CA"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/zillow-property-listings-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 = {
    "startUrls": [{ "url": "https://www.zillow.com/homes/for_sale/San-Francisco,-CA_rb/" }],
    "locations": ["San Francisco, CA"],
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/zillow-property-listings-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 '{
  "startUrls": [
    {
      "url": "https://www.zillow.com/homes/for_sale/San-Francisco,-CA_rb/"
    }
  ],
  "locations": [
    "San Francisco, CA"
  ]
}' |
apify call fetch_cat/zillow-property-listings-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Zillow Property Listings Scraper",
        "description": "Scrape public Zillow sale, rent, and sold property search results with prices, addresses, beds, baths, brokers, images, and map coordinates.",
        "version": "0.1",
        "x-build-id": "1fIHiBUhpeN2VSvZd"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~zillow-property-listings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-zillow-property-listings-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/fetch_cat~zillow-property-listings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-zillow-property-listings-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/fetch_cat~zillow-property-listings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-zillow-property-listings-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": {
                    "startUrls": {
                        "title": "Zillow search URLs",
                        "type": "array",
                        "description": "One or more public Zillow search result URLs, such as city sale or rental searches.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Optional city or area names. The actor converts each location into a Zillow search URL using the selected listing type.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "listingType": {
                        "title": "Listing type for locations",
                        "enum": [
                            "for_sale",
                            "for_rent",
                            "sold"
                        ],
                        "type": "string",
                        "description": "Used when generating Zillow search URLs from locations. Start URLs keep their own listing type.",
                        "default": "for_sale"
                    },
                    "maxItems": {
                        "title": "Maximum listings",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of unique Zillow listings to save.",
                        "default": 20
                    },
                    "maxPages": {
                        "title": "Maximum pages per search",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many Zillow result pages to request for each search source.",
                        "default": 1
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy is recommended because Zillow can block datacenter traffic.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "US"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
