# Zillow Open Houses Scraper (`crawlerbros/zillow-open-houses-scraper`) Actor

Scrape upcoming open house events from Zillow by location. Returns date, time, address, price, beds/baths, agent, and full property details for each scheduled open house.

- **URL**: https://apify.com/crawlerbros/zillow-open-houses-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Real estate, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 8 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 Open Houses Scraper

Scrape upcoming open house events from Zillow by location. Get date, time, address, price, beds/baths, full property details, and the hosting agent — all in one structured dataset.

### What you get

Each result contains:
- **Open house schedule** — all upcoming events with start/end times and type (in-person or virtual)
- **Property details** — address, price, beds, baths, sqft, year built, lot size, HOA fee
- **Agent info** — listing agent name, phone, and brokerage
- **Photos** — array of property photo URLs
- **Convenience field** — `nextOpenHouse` points to the soonest upcoming event

### Input

| Field | Type | Required | Description |
|---|---|---|---|
| `search` | string | one of search/startUrls | Free-text location: city, ZIP code, neighborhood (e.g. `Austin, TX`, `90210`) |
| `startUrls` | array | one of search/startUrls | Zillow search or open-house URLs — the open house filter is added automatically |
| `dateFrom` | string | no | Only include events on or after this date (`YYYY-MM-DD`) |
| `dateTo` | string | no | Only include events on or before this date (`YYYY-MM-DD`) |
| `maxItems` | integer | no | Maximum listings to return (1–500, default: 100) |
| `scrapeDetails` | boolean | no | Fetch full property details — sqft, photos, agent info (default: true) |

### Output

One record per property. Open house events are nested under `openHouses`.

```json
{
  "url": "https://www.zillow.com/homedetails/123-main-st/12345678_zpid/",
  "zpid": 12345678,
  "status": "FOR_SALE",
  "address": "123 Main St",
  "city": "Austin",
  "state": "TX",
  "zipCode": "78701",
  "latitude": 30.2672,
  "longitude": -97.7431,
  "price": 450000,
  "zestimate": 455000,
  "beds": 3,
  "baths": 2,
  "sqft": 1850,
  "yearBuilt": 2005,
  "propertyType": "SINGLE_FAMILY",
  "hoaFee": 150,
  "agentName": "Jane Smith",
  "agentPhone": "512-555-0100",
  "brokerName": "Realty Austin",
  "photos": ["https://photos.zillowstatic.com/fp/abc123.jpg"],
  "openHouses": [
    {
      "startDateTime": "2026-05-03T13:00:00",
      "endDateTime": "2026-05-03T15:00:00",
      "openHouseType": "INPERSON"
    }
  ],
  "nextOpenHouse": {
    "startDateTime": "2026-05-03T13:00:00",
    "endDateTime": "2026-05-03T15:00:00",
    "openHouseType": "INPERSON"
  },
  "scrapedAt": "2026-04-30T10:00:00Z"
}
````

### Use cases

- **Home buyers** — build a weekend open house calendar for a target neighborhood or ZIP code
- **Real estate agents** — monitor competitor open house activity in your market
- **Market researchers** — track open house frequency and pricing by area over time
- **Lead generation** — identify active listings with upcoming open houses

### Examples

**Open houses this weekend in Austin:**

```json
{
  "search": "Austin, TX",
  "dateFrom": "2026-05-04",
  "dateTo": "2026-05-05",
  "maxItems": 100
}
```

**All upcoming open houses in a single ZIP, with full property detail:**

```json
{
  "search": "78704",
  "scrapeDetails": true,
  "maxItems": 50
}
```

**Pull from a Zillow search URL directly:**

```json
{
  "startUrls": [
    "https://www.zillow.com/austin-tx/open-houses/"
  ]
}
```

### FAQ

**How many open houses can I scrape?**
Up to 500 per run (set via `maxItems`). Run multiple times with different locations or date ranges to collect more.

**Can I filter by date?**
Yes. Use `dateFrom` and `dateTo` (format: `YYYY-MM-DD`) to get only open houses within a date range. Both fields are optional — you can set just one.

**What is `nextOpenHouse`?**
A convenience field containing the soonest upcoming open house event for the property. It always equals `openHouses[0]` (events are sorted chronologically).

**What does `openHouseType` mean?**
Either `INPERSON` (on-site visit) or `VIRTUAL` (online showing).

**Can I use Zillow URLs directly?**
Yes. Paste any Zillow search or property URL into `startUrls`. The open house filter is injected automatically if not already present.

**Does it work for all US markets?**
Yes. Any location searchable on Zillow works — city names, ZIP codes, neighborhoods, or full addresses.

**How fresh is the data?**
The scraper fetches live data from Zillow at the time of each run. Open house schedules are time-sensitive, so run it close to when you plan to use the results.

**Why are some fields missing from certain records?**
Empty, null, and zero-value fields are omitted to keep output clean. Fields like `sqft` or `hoaFee` may not be available for every listing.

# Actor input Schema

## `search` (type: `string`):

Free-text location to search for open houses: city name, ZIP code, neighborhood, or address (e.g. 'Austin, TX', '90210', 'Brooklyn, NY').

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

Zillow search or open-house URLs to scrape. The open house filter is injected automatically if not present.

## `dateFrom` (type: `string`):

Include only open houses on or after this date (e.g. '2026-05-01'). Leave blank for no lower bound.

## `dateTo` (type: `string`):

Include only open houses on or before this date (e.g. '2026-05-31'). Leave blank for no upper bound.

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

Maximum number of open house listings to return (1–500).

## Actor input object example

```json
{
  "search": "Austin, TX",
  "maxItems": 10
}
```

# Actor output Schema

## `openHouses` (type: `string`):

Dataset of scraped open-house listings with embedded schedule.

# 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 = {
    "search": "Austin, TX",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/zillow-open-houses-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 = {
    "search": "Austin, TX",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/zillow-open-houses-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 '{
  "search": "Austin, TX",
  "maxItems": 10
}' |
apify call crawlerbros/zillow-open-houses-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Zillow Open Houses Scraper",
        "description": "Scrape upcoming open house events from Zillow by location. Returns date, time, address, price, beds/baths, agent, and full property details for each scheduled open house.",
        "version": "0.1",
        "x-build-id": "oZ3G0e0V2dAHCJOWO"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~zillow-open-houses-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-zillow-open-houses-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/crawlerbros~zillow-open-houses-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-zillow-open-houses-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/crawlerbros~zillow-open-houses-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-zillow-open-houses-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": {
                    "search": {
                        "title": "Location Search",
                        "type": "string",
                        "description": "Free-text location to search for open houses: city name, ZIP code, neighborhood, or address (e.g. 'Austin, TX', '90210', 'Brooklyn, NY')."
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Zillow search or open-house URLs to scrape. The open house filter is injected automatically if not present.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "dateFrom": {
                        "title": "Date From (YYYY-MM-DD)",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Include only open houses on or after this date (e.g. '2026-05-01'). Leave blank for no lower bound."
                    },
                    "dateTo": {
                        "title": "Date To (YYYY-MM-DD)",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Include only open houses on or before this date (e.g. '2026-05-31'). Leave blank for no upper bound."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of open house listings to return (1–500).",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```