# Zillow Open Houses \[From $1.4💰] Exact Dates & Times | Any City (`memo23/zillow-open-houses-scraper`) Actor

\[From $1.4💰] Every upcoming Zillow open house in any US city or ZIP, with the exact dates and times of each showing. Returns price, beds, baths, sq ft, listing agent, coordinates and the full property record. Filter by price, beds or home type. Residential proxies included. JSON, CSV or Excel.

- **URL**: https://apify.com/memo23/zillow-open-houses-scraper.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** Real estate, Lead generation, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.40 / 1,000 open house listings

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

Find **every upcoming open house on Zillow** for any US city, neighborhood, or ZIP code — with the exact **dates and times**, address, price, beds/baths, listing agent, and (optionally) the complete property record including price history, tax history, schools, and photos.

Type a location, press Start, and get a clean list of every home you can walk into this weekend — as JSON, CSV, or Excel.

### ⭐ Why use this Zillow open house scraper?

- **Open houses only** — the filter runs server-side on Zillow's own search API, so you get exactly the listings with a scheduled open house event, not everything for sale.
- **Exact event times** — every row carries `openHouseSchedules` with start & end timestamps for each showing (many homes have several).
- **Full property depth** — unlike lightweight open-house scrapers, each row can include the entire property record: description, photos, price history, tax history, Zestimate, schools, HOA, lot size, and agent/broker contact info.
- **Any way you search** — plain locations ("Denver, CO", "78704"), or paste a Zillow search URL (drawn map area, custom filters); the open-house filter is stacked on top automatically.
- **Spreadsheet-ready** — optional flattened output adds human-readable `Open House Times` and `Open House Count` columns.
- **Agent email enrichment (optional)** — match the listing agent against a 420,000+ US agent database and add their direct email & phone to each row.

### 📋 What data does it extract?

| Field group | Columns |
|---|---|
| Open house events | `openHouseSchedules` (start & end time per showing) — plus `Open House Times` / `Open House Count` in flattened output |
| Listing basics | `Address`, `City`, `State`, `Zip Code`, `Price`, `Status`, `URL`, `Date` |
| Home facts | `Beds`, `Baths`, `Sq Ft`, `Year Built`, `Acres` |
| Location | `Latitude`, `Longitude` |
| Agent & broker | `Agent Name`, `Agent Number`, `Broker Name`, `Broker Number` — plus optional email enrichment |
| Listing text | `Description`, `Zoning`, `School 1`–`3`, `Property Subtype` |
| Full record | `details` — the complete Zillow property object (photos, price & tax history, Zestimate, schools, HOA, MLS ID & status, 200+ fields) |

### 🚀 How it works

1. **Enter locations** — one or more cities/ZIPs (or paste Zillow search URLs).
2. **Set Max items** — how many open-house listings you want.
3. **Run** — the scraper resolves each region, applies Zillow's "must have open house" filter server-side, then (by default) visits every matching listing for the exact open-house schedule and full details.

Results land in the dataset, exportable as JSON, CSV, Excel, XML, or via API.

### ⚙️ Input configuration

```json
{
    "searchLocation": ["Austin, TX"],
    "maxItems": 100,
    "includePropertyDetails": true
}
```

| Field | Type | Description |
|---|---|---|
| `searchLocation` | array | Cities, neighborhoods, or ZIP codes — one search each |
| `startUrls` | array | Alternative: any Zillow search URLs; the open-house filter is added on top |
| `maxItems` | integer | Cap on returned open-house listings (default 100) |
| `priceMin` / `priceMax` | integer | Optional price range |
| `bedsMin` / `bathsMin` | integer | Optional minimum beds / baths |
| `homeTypes` | array | Limit to houses, condos, townhomes, … |
| `includePropertyDetails` | boolean | Fetch each listing's full record incl. exact open-house times (default **true**) |
| `flatOutput` | boolean | Flat spreadsheet-style rows instead of nested JSON |
| `enrichEmails` | boolean | Add the listing agent's direct email (billed only per email found) |

### 📦 Output sample

```json
{
    "Date": "2026-08-04",
    "Address": "4617 Englewood Dr #2",
    "City": "Austin",
    "State": "TX",
    "Zip Code": "78745",
    "Price": 565000,
    "Beds": 2,
    "Baths": 3,
    "Sq Ft": 1210,
    "Year Built": 2023,
    "Status": "FOR_SALE",
    "Agent Name": "Brande Draper",
    "Agent Number": "(512) 289-4444",
    "Broker Name": "Compass RE Texas, LLC",
    "Latitude": 30.208956,
    "Longitude": -97.79213,
    "URL": "https://www.zillow.com/homedetails/4617-Englewood-Dr-2-Austin-TX-78745/2069574604_zpid/",
    "openHouseSchedules": [
        { "startTime": "2026-08-08 13:00:00", "endTime": "2026-08-08 15:00:00" },
        { "startTime": "2026-08-09 12:00:00", "endTime": "2026-08-09 14:00:00" }
    ],
    "details": { "…full property record: photos, price & tax history, Zestimate, schools, HOA…": "…" }
}
```

With **Flattened output** enabled, the nested `details` blob is replaced by ~35 extra scalar columns — the schedule arrives pre-formatted and the record gains MLS, tax and history fields:

| Address | Price | Beds | Baths | Sq Ft | Open House Times | Open House Count | Agent Name |
|---|---|---|---|---|---|---|---|
| 4617 Englewood Dr #2 | 565000 | 2 | 3 | 1210 | 2026-08-08 13:00–15:00 | 2026-08-09 12:00–14:00 | 2 | Brande Draper |

Flattened output also adds `Listing Date`, `Days on Zillow`, `MLS ID`, `MLS Status`, `Agent Email`, `Annual Tax`, `Tax Assessed Value`, `Price History`, `Tax History`, `Detail URL` and more — ideal for CSV/Excel. Photos and the raw nested record are only in the default (non-flattened) shape.

### 🔑 Key output fields

- `openHouseSchedules` — array of `{ startTime, endTime }` for every scheduled showing, in the listing's **local wall-clock time** (no timezone conversion). Homes often have two or more.
- `Open House Times` / `Open House Count` — the same schedule pre-formatted as one readable cell plus a count, in flattened output.
- `Beds` / `Baths` / `Sq Ft` / `Year Built` — headline home facts, on every row in both modes.
- `URL` — direct link to the Zillow listing.
- `details` — the complete property record (default mode only; ~200 fields).

Column names are Title Case (`Address`, `Zip Code`, `Agent Name`) so they read cleanly as spreadsheet headers.

### 💡 Use cases

- **Buyers & house hunters** — build your weekend open-house route for a whole city in one run.
- **Real-estate agents & teams** — monitor competitor open houses, plan canvassing, and (with email enrichment) reach the listing agent directly.
- **Investors & wholesalers** — open houses signal motivated sellers; walk properties before making offers.
- **Proptech & data teams** — feed open-house event data into apps, maps, CRMs, or market dashboards.
- **Newsletters & local media** — publish "open houses this weekend in <city>" roundups automatically.

### ❓ FAQ

**Does it really return only listings with open houses?**
Yes. The filter is applied server-side on Zillow's search API (the same "Must have open house" toggle as on zillow.com), then each listing's detail record carries the exact schedule.

**How fresh is the data?**
Every run scrapes Zillow live — you get the open houses listed at the moment the run executes. Schedule the actor daily or weekly for a rolling feed.

**Which regions are covered?**
Everywhere Zillow operates — all US states plus Canadian listings on zillow.com.

**Do I need proxies?**
No. The actor ships with built-in residential proxies at no extra cost.

**Can I search several cities at once?**
Yes — add one location per line; each is searched independently in the same run.

**Why is a listing returned without times?**
Keep **Include full property details** on (the default) — the exact schedule lives on the listing's detail record. With it off, the run is faster and cheaper but rows only mark that an open house exists, and `Beds` / `Baths` / `Sq Ft` are unavailable too.

**Are the times in my timezone?**
No — they are the listing's local wall-clock times, exactly as Zillow shows them to a buyer in that market. A 1:00 PM open house in Austin reads `13:00:00` whatever timezone you run from.

### 🛟 Support

Found an issue or missing a field? Open an issue on the actor's **Issues** tab — it is monitored daily and most reports get a fix or an answer within 24 hours.

### 🧩 Additional services

Need a custom pipeline (specific columns, delivery to your DB/S3/webhook, merged multi-source feeds)? Open an issue describing what you need or contact the author through the actor page.

### 🔎 Explore more scrapers

- [Zillow Scraper (full search, sold, rentals, monitoring)](https://apify.com/memo23/zillow-scraper-ppe) — the flagship this actor is built on: every listing status, Monitoring Mode change feeds, agent enrichment, and more.
- [All actors by memo23](https://apify.com/memo23) — 100+ maintained scrapers for real estate, jobs, directories, and reviews.

### 🤖 For AI Agents & LLM Apps

This actor is MCP-ready: call it from AI agents (Claude, GPT, LangChain, LlamaIndex, or the Apify MCP server) to answer questions like *"which open houses can I visit in Austin this Saturday under $600k?"*. Structured JSON output with stable field names makes rows directly usable as tool results — `openHouseSchedules` for event reasoning, `details` for grounded property Q\&A.

### ⚠️ Disclaimer

This actor is not affiliated with, endorsed by, or connected to Zillow Group. It extracts only publicly visible listing information for lawful purposes such as market research and personal planning; no login is used and no private data is accessed. You are responsible for how you use the data — respect Zillow's terms and applicable laws (including local regulations on personal-data processing).

***

*zillow open house scraper · scrape zillow open houses · open house finder · zillow open house data extractor · open houses this weekend · zillow open house API · real estate open house scraper · export zillow open houses to excel*

# Actor input Schema

## `searchLocation` (type: `array`):

City, neighborhood, or ZIP code — e.g. "Austin, TX", "Brooklyn, NY", or "78704". One per line; each becomes its own open-house search.

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

Alternative to Search location(s): paste any Zillow search URL (map area, drawn region, filtered search). The open-house filter is applied automatically on top of whatever the URL already filters.

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

Maximum number of open-house listings to return.

## `priceMin` (type: `integer`):

Minimum listing price. Leave blank for no minimum.

## `priceMax` (type: `integer`):

Maximum listing price. Leave blank for no maximum.

## `bedsMin` (type: `integer`):

Minimum bedrooms.

## `bathsMin` (type: `integer`):

Minimum bathrooms.

## `homeTypes` (type: `array`):

Limit to specific property types. Leave empty for all.

## `includePropertyDetails` (type: `boolean`):

Fetch each listing's detail page for the exact open-house dates & times (openHouseSchedules), full description, photos, price & tax history, schools, and agent info. Recommended — without it rows only mark that a listing HAS an open house, not when.

## `flatOutput` (type: `boolean`):

Each row becomes a simple flat object with "Open House Times" and "Open House Count" columns plus the most requested property columns — ideal for CSV/Excel. When off, rows carry the raw openHouseSchedules array and the full details object.

## `enrichEmails` (type: `boolean`):

Adds the listing agent's email and phone to each open-house row — matched from our database of 420,000+ U.S. agents. Only charged when an email is actually returned.

## `maxConcurrency` (type: `integer`):

Maximum number of pages processed in parallel.

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

Number of times a failed request is retried before giving up.

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

Leave empty — the actor already routes all traffic through its own built-in residential proxy at no extra cost to you. Only set this if you want to use your own proxies.

## `openHousesOnly` (type: `boolean`):

Always on for this actor — every returned listing has an upcoming open house.

## Actor input object example

```json
{
  "searchLocation": [
    "Austin, TX"
  ],
  "maxItems": 100,
  "includePropertyDetails": true,
  "flatOutput": false,
  "enrichEmails": false,
  "maxConcurrency": 20,
  "maxRequestRetries": 5,
  "openHousesOnly": true
}
```

# Actor output Schema

## `results` (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 = {
    "searchLocation": [
        "Austin, TX"
    ],
    "includePropertyDetails": true,
    "openHousesOnly": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/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 = {
    "searchLocation": ["Austin, TX"],
    "includePropertyDetails": True,
    "openHousesOnly": True,
}

# Run the Actor and wait for it to finish
run = client.actor("memo23/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 '{
  "searchLocation": [
    "Austin, TX"
  ],
  "includePropertyDetails": true,
  "openHousesOnly": true
}' |
apify call memo23/zillow-open-houses-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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