# Zillow Upcoming Open House Finder by City or ZIP (`nimbryxo-studio/zillow-upcoming-open-house-finder-by-city-or-zip`) Actor

Find upcoming Zillow open houses by city, ZIP, or search URL, with showing start and end times plus property price, beds/baths, square footage and location.

- **URL**: https://apify.com/nimbryxo-studio/zillow-upcoming-open-house-finder-by-city-or-zip.md
- **Developed by:** [Nimbryxo-studio](https://apify.com/nimbryxo-studio) (community)
- **Categories:** Real estate, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

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

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

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

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

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

# README

## Zillow Upcoming Open House Finder by City or ZIP

Collect upcoming open houses listed on Zillow for a city or ZIP code, with each showing's start and end time alongside the property's price, beds/baths, square footage and location. Search by free-text location or paste a Zillow search/open-houses URL directly.

### What this actor does

- Searches Zillow's open-house listings for a city or ZIP code, or reads a pasted Zillow search URL
- Returns the scheduled showings Zillow lists for each property, with a `nextOpenHouse` convenience field pointing to the soonest one
- Leaves out properties that have no showing schedule, so every record has at least one open house
- Filters results to a specific date range so you only get showings happening when you can attend
- Pulls core property data (price, beds, baths, square footage, year built, tax assessment, lot area) straight from the search results
- Empty fields are omitted from each record

### Output per property

- `url`, `zpid` — Zillow property page URL and ID
- `status` — listing status (e.g. `FOR_SALE`)
- `address`, `city`, `state`, `zipCode`
- `latitude`, `longitude`
- `price`, `zestimate`, `currency`
- `beds`, `baths`, `sqft`
- `yearBuilt`, `propertyType`, `daysOnZillow`
- `taxAssessedValue`, `lotAreaValue`, `lotAreaUnit`
- `openHouses[]` — each scheduled showing as `{startDateTime, endDateTime, openHouseType}`, sorted chronologically; times are the property's local time without a timezone offset
- `nextOpenHouse` — the earliest entry from `openHouses`, duplicated here for convenience
- `scrapedAt` — ISO timestamp of when the record was collected
- With `scrapeDetails` enabled, each property's own Zillow page is also visited, adding `lotSize`, `stories`, `hoaFee`, `pricePerSqft`, `brokerName`, `agentName`, `agentPhone`, `description`, and `photos[]`, and refining `address`, `city`, `state`, `zipCode`, `latitude`, `longitude`, `price`, `zestimate`, `beds`, `baths`, `sqft`, `yearBuilt`, `propertyType`, and `daysOnZillow` with the detail page's own values

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `search` | string | – | Free-text location, best as a city and state or a ZIP code (e.g. `Austin, TX`, `90210`) |
| `startUrls` | array | – | Zillow search or open-houses URLs (up to 25 result pages each). Listings without a showing schedule are skipped; individual property (`/homedetails/`) URLs are not supported |
| `dateFrom` | string | – | Only include showings on or after this date (`YYYY-MM-DD`); properties with no showing in range are dropped |
| `dateTo` | string | – | Only include showings on or before this date (`YYYY-MM-DD`) |
| `scrapeDetails` | boolean | `false` | Also visit each property's own Zillow page for lot size, stories, HOA fee, price per square foot, listing agent/broker name and phone, description, and photos. Slower; leave off for a quicker listing-only run |
| `maxItems` | integer | `100` | Maximum properties to return (1–500). Fewer come back when Zillow lists fewer open houses for the area |

At least one of `search` or `startUrls` is required.

#### Example: open houses this weekend in Austin

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

#### Example: upcoming open houses in one ZIP code

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

#### Example: scrape from a Zillow search URL

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

### Use cases

- **Home buyers** — build a weekend viewing itinerary for a target neighborhood or ZIP code
- **Real estate agents** — track open house activity from competing listings in your market
- **Market researchers** — monitor how often properties in an area hold open houses and at what price point
- **Lead-generation teams** — surface actively-marketed listings that are hosting a showing soon

### FAQ

**Does this need a Zillow account or login?**
No. It reads Zillow's public open-house search results.

**Can I filter to a specific date range?**
Yes. Set `dateFrom`, `dateTo`, or both — leave either blank for no bound on that side.

**What does `nextOpenHouse` mean?**
It's the earliest entry in that property's `openHouses` array, duplicated at the top level so you don't have to sort the array yourself.

**What's the difference between `INPERSON` and `VIRTUAL` in `openHouseType`?**
`INPERSON` is an on-site walkthrough; `VIRTUAL` is an online showing. When Zillow's search data gives a showing time without a type, the actor labels it `INPERSON`, so treat that value as the default rather than a guarantee.

**Can I pass a Zillow URL instead of a location?**
Yes. Paste a Zillow search or open-houses URL into `startUrls`. The URL is read as-is, and any listing on it without a showing schedule is skipped, so an open-houses URL (such as `https://www.zillow.com/austin-tx/open-houses/`) gives the fullest results. Direct individual property URLs aren't supported.

**Why are fields like `zestimate`, `yearBuilt`, or `taxAssessedValue` missing on some properties?**
They come from the summary Zillow shows in its search results, and not every listing carries them there. Agent/broker name and phone, photos, and full descriptions are only collected when `scrapeDetails` is enabled.

**Which locations work in `search`?**
City-and-state pairs (`Austin, TX`) and ZIP codes (`78704`) work best, because the text is turned into Zillow's own open-houses page for that place. For neighborhoods or unusual areas, open the open-houses page on Zillow and paste its URL into `startUrls` instead.

**Is this affiliated with Zillow?**
No. This is an independent actor that reads Zillow's public open-house pages and is not operated or endorsed by Zillow.

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

## `scrapeDetails` (type: `boolean`):

Also visit each property's own Zillow page for lot size, stories, HOA fee, price per square foot, listing agent/broker name and phone, description and photos. Slower; turn off for a quick listing.

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

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

## Actor input object example

```json
{
  "search": "Austin, TX",
  "scrapeDetails": false,
  "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",
    "scrapeDetails": false,
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("nimbryxo-studio/zillow-upcoming-open-house-finder-by-city-or-zip").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",
    "scrapeDetails": False,
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("nimbryxo-studio/zillow-upcoming-open-house-finder-by-city-or-zip").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "search": "Austin, TX",
  "scrapeDetails": false,
  "maxItems": 10
}' |
apify call nimbryxo-studio/zillow-upcoming-open-house-finder-by-city-or-zip --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nimbryxo-studio/zillow-upcoming-open-house-finder-by-city-or-zip"
        }
    }
}
```

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

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/MJ6qfmpk6MQzUARaD/builds/79XPummkw8TWaaWBw/openapi.json