# Zillow Price Drop Monitor | $0.50/1K | Price Changes (`x_guru/zillow-price-drop-monitor`) Actor

Track Zillow price drops and status changes with automatic complete-scan baselines for scheduled runs. Export property checks to CSV; unchanged checks are billed.

- **URL**: https://apify.com/x_guru/zillow-price-drop-monitor.md
- **Developed by:** [Hundevmode Labs](https://apify.com/x_guru) (community)
- **Categories:** Real estate, Automation
- **Stats:** 2 total users, 1 monthly users, 89.5% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 paid plans: saved property checks

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Price Drop Monitor

Track Zillow price drops, price increases and listing status changes. Run the same search on an Apify schedule: each scan automatically compares with the latest complete scan for your account and filters, and a complete scan becomes the next baseline.

**Result pricing:** $0.50/1,000 property-check rows on paid Apify plans; $1.00/1,000 on Free. Automatic source access recovery is included. No Zillow login or additional service is required.

### What you can collect

- Create the first baseline with a complete scan of a city, ZIP or Zillow search URL.
- Rerun the same input manually or on a schedule; no previous run ID needs updating.
- Keep the previous baseline when a scan stops at a result, spending or source limit.
- Export baseline, new, price_drop, price_increase, status_changed and unchanged checks; missing observations require full coverage.

### How to use Zillow Price Drop Monitor

1. Enter a narrow search. Keep automatic baseline updates enabled and leave the fixed previous scan ID blank.
2. Set **Maximum results this run** and optional filters.
3. Set a spending limit in Apify run options, then click **Start**.
4. Open the results, review the coverage summary, and download CSV, Excel or JSON.

#### Quick-start input

```json
{
  "locations": [
    "Boston, MA"
  ],
  "minPrice": 10000000,
  "maxResults": 1000
}
```

This example is a starting point; replace its sources with your own. URL-only runs should leave locations empty.

### Input options

| Input | Purpose | Default |
| --- | --- | --- |
| `locations / startUrls` | Cities with state, ZIP codes or Zillow search URLs. Keep exactly the same query for comparison. | Empty |
| `listingType` | sale, rent or sold. | sale |
| `maxResults` | Maximum check rows this run, including unchanged and not_observed rows. Choose enough to finish the query. | 100 |
| `autoBaseline` | Automatically compare with and update the latest complete scan for this account and exact filters. | true |
| `previousMonitorRunId` | Optional fixed complete run from this actor/account. Overrides automatic mode and leaves its saved baseline unchanged. | Unset |
| `resumeFromRunId` | Continue an unfinished scan with its original pinned comparison. Copy PAGINATION.nextInput. | Unset |
| `Price and size filters` | Narrow the query so it can complete within the collection and spending limits. Changed filters create a separate automatic baseline. | Unset |
| `advanced` | Optional request, time, download and retry ceilings. | 300 requests, 600 seconds, 50 MB on paid plans |

Manually supplied source lists accept up to 100 entries. You may combine supported input methods; earlier sources can consume the shared result limit before later ones are reached.

### Output: CSV and JSON fields

Each result is one property check record. Missing source fields are `null`. The default table uses readable column labels while exports keep stable field names.

| Data | Columns |
| --- | --- |
| Property | `recordId`, `zpid`, `url`, `address`, `city`, `state`, `zipcode` |
| Comparison | `changeType`, `previousPrice`, `observedPrice`, `status` |
| Collection | `observedAt`, `sourceCoverageComplete` |

Nested attributes, where present, are serialized as JSON strings so CSV remains flat. Errors are not mixed into paid dataset rows. **Coverage and limits** (`RUN_SUMMARY`), **Source issues** (`ERRORS`) and **Continue collection** (`PAGINATION`) are separate run output links. `REQUEST_METRICS` and `CHECKPOINT` are available in key-value storage.

Open **Automatic monitoring and baseline update** in the run output: `updateStatus=updated` confirms that the scan became the next automatic baseline. A new comparison baseline is usable only after the whole scan completes. A successful run can be partial because of limits or source restrictions; narrow its search or continue unfinished work before treating it as a complete baseline.

### 💳 Pricing and spending limits

| Apify account | Price per 1,000 property-check rows | Collection allowance |
| --- | ---: | --- |
| Paid plan | $0.50 | Requested count, source availability and run limits |
| Free | $1.00 | 100 rows across one collection and its continuation chain |

Every saved property check is billed, including baseline, unchanged and not-observed rows. The price is per check, not per price change.

The platform actor-start event is **$0.00005 per GB of allocated memory, with a minimum of one event**. A 256 MB run therefore pays $0.00005 to start. Each new continuation run and each Resurrect may incur another start event. There are no separate enrichment or access-recovery add-ons. Platform usage is included in the PPE policy; no extra dataset-item event is configured.

Apify authenticates the account plan automatically; input cannot select the cheaper rate. **Free is an Apify account plan, not zero-price output:** results consume available account credits. Free runs also stop at 40 requests, 180 seconds or 10 MB of compressed downloaded responses. These ceilings cannot be raised in the input. Downloads are checked between responses, so one response can exceed the remaining traffic allowance. Independent fresh collections have independent allowances; this is not an account-wide monthly quota.

Minimum permitted Max total charge: $0.00105, covering the start event and at least one result at the highest Free rate. This is a minimum budget setting, not a minimum bill: only the start and saved result events are charged. The same result rates apply to all paid Apify plans.

Set **Max total charge** in Apify run options, or `maxTotalChargeUsd` through the API. The requested result count is not a dollar budget. The SDK checks remaining run budget before saving charged rows, and Apify can stop a run when its budget is reached. Paid-account credit balance and overage settings are separate from this run limit. Rates are configured for the current private release; the actor has not been published in Apify Store.

### 🔁 Continue after a limit or source error

1. Keep the saved dataset and wait until the previous run has finished.
2. Open **Continue collection** (`PAGINATION`) in the run output.
3. If `hasMore=true`, copy the **full `nextInput`** into a new run of this same actor. It includes `resumeFromRunId`.
4. Keep the query, filters and any monitor baseline unchanged. You may change `maxResults` and advanced collection limits; ZIP per-code quotas stay unchanged.
5. Set a new spending budget. Download this batch’s dataset and combine it with your earlier batches.

The next batch contains newly saved rows only. Earlier rows are skipped and are not charged again along that continuation chain. Use the **latest** finished batch: branching twice from an older run can create overlapping datasets. The previous run must belong to your own account and this actor, and its storage must remain available.

| Stop or issue | Next step |
| --- | --- |
| Result, request, time or download ceiling | Use `PAGINATION.nextInput` if `hasMore=true`; adjust the next batch’s limits. |
| Temporary restriction or HTTP 403 | Bounded automatic recovery has already been attempted. Retain progress and try the continuation later. A fresh run does not guarantee that access is restored. |
| Spending limit | Keep saved rows and resume with a new per-run budget. The budget is not shared across the chain. |
| Free collection allowance | Continuation and Resurrect do not replenish it. Upgrade the account before collecting beyond the Free allowance. |
| Invalid input or changed query | Correct the input; keep the original query for continuation or start a separate collection. |
| Missing checkpoint after a hard stop | A usable continuation may be unavailable. Keep any saved rows; a fresh collection cannot guarantee deduplication against that dataset. |

Apify **Resurrect** restarts the same run and storage. `resumeFromRunId` creates a separate batch and dataset. Do not use both methods simultaneously. A requested count is a ceiling, not a promise that Zillow has that many accessible records.

### Run through the Apify API

The same JSON input works in Apify Console and through the [Apify Actor API](https://docs.apify.com/api/v2/actor-runs). Start a run, wait for it to finish, then export its dataset as JSON, CSV or Excel. Use the actor ID from its Console page and your own Apify API token; no Zillow API key is required. Pass `maxTotalChargeUsd` as a run option rather than an input field. Never put API tokens in the input.

### Choose the right Zillow actor

Choose this actor to compare complete scans taken at different times. Use **Zillow Scraper** for a single inventory export, or **Zillow ZIP Code Scraper** for a territory export with separate ZIP quotas.

### Frequently asked questions

#### Do I pay only when a price changes?

No. Every saved property check is billed, including baseline, unchanged and not_observed rows. Automatic baseline storage has no additional result event or enrichment fee.

#### How do I set up scheduled monitoring?

Keep autoBaseline=true and previousMonitorRunId blank. Complete a first run, then save the same input as an Apify task and schedule that task in Console. Do not put resumeFromRunId in a recurring schedule: continuation is only for finishing one interrupted scan. Each complete scheduled scan becomes the next baseline. Configure maximum spend and choose an interval longer than typical scan duration.

#### What happens after a 403 or spending stop?

Saved rows remain available. The automatic baseline is preserved until the entire scan and any missing-observation checks finish. Copy PAGINATION.nextInput to continue; the original comparison is pinned across batches. Recovery may still encounter source restrictions.

#### Can two scans overwrite one another?

Overlapping automatic runs with the same account and exact filters are skipped with stopReason=monitor_already_running before collecting property checks. A stopped process leaves an expiring lock. If an old continuation finishes after a newer full scan, it reports newer_baseline_preserved and cannot replace that newer baseline.

#### Does not_observed mean sold or delisted?

No. It means the property was not seen in that completed query. A price moving outside the filters or source availability can also remove it from the search.

#### Can I compare against a fixed run?

Yes. Supply a complete same-query run in previousMonitorRunId. This overrides automatic mode for that run and does not update its automatic baseline. With autoBaseline=false and no explicit run ID, each independent run creates its own baseline.

#### What is retained between scheduled runs?

A compact latest complete snapshot is stored in named Apify storage for this actor, account and exact query. It survives expiration of the original run storage. Deleting that named storage resets automatic monitoring. Baselines are not shared across accounts or different filters.

#### Does it send alerts?

The actor exports changes and monitoring state. Set up your own Apify integration or webhook to deliver notifications; no notification destination is configured by this actor.

#### What if price and status both change?

status_changed takes priority. Previous and observed price fields remain available for your own price comparison.

#### Is this an official Zillow API?

No. This is an independent actor callable through the Apify API. It is not affiliated with, sponsored or endorsed by Zillow. Source fields, layouts and access can change; complete extraction and uninterrupted access are not guaranteed.

### Automatic baseline state

`MONITOR_STATE` reports `mode`, `comparisonRunId`, `baselineUpdated` and `updateStatus`. `updated` means the next run uses this complete scan; `incomplete_scan` preserves the old baseline; `already_running` skips an overlap; `lock_lost` stops collection safely; `storage_unavailable` reports a temporary Apify state-storage issue with continuation available; `newer_baseline_preserved` protects a newer completed scan from a stale continuation. Manual comparisons show `manual_baseline`. `MONITOR_BASELINE` describes the current scan and its completeness, which differs from the comparison used for this scan. Pre-automatic continuation checkpoints retain their original manual semantics.

The named snapshot survives default run-storage retention. The snapshot and coordination queue appear in your Apify Storage under an account/query-specific `zillow-monitor-…` name. Both are actor-owned resources in your account with restricted access; remove them when you no longer need that monitor. Ordinary Apify storage/API usage applies.

Apify references: [Schedules](https://docs.apify.com/actors/running/schedules), [named key-value storage](https://docs.apify.com/storage/key-value-store), [limited permissions](https://docs.apify.com/actors/running/permissions).

# Actor input Schema

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

US city and state or five-digit ZIP, one per entry. Leave empty when using URLs only. If both are supplied, both are collected up to the shared result limit.

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

Keep this selection unchanged when continuing a collection.

## `maxResults` (type: `integer`):

Maximum NEW property-check rows saved in this run (1–100,000). Free: 100 rows per collection across continuation batches. Source availability, time and Max total charge can stop earlier. Includes unchanged checks. Narrow the search until the whole scan completes before using it as a baseline.

## `autoBaseline` (type: `boolean`):

Use the latest complete scan for your account and these filters. The first complete scan starts monitoring. Incomplete scans preserve the previous baseline.

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

Paste a Zillow search URL. This actor applies its selected listing type. Property detail, agent and building URLs are not supported here.

## `minPrice` (type: `number`):

Optional Zillow search filter. Prices are USD; rental prices are monthly. Living area is in square feet.

## `maxPrice` (type: `number`):

Optional Zillow search filter. Prices are USD; rental prices are monthly. Living area is in square feet.

## `minBedrooms` (type: `number`):

Optional Zillow search filter. Prices are USD; rental prices are monthly. Living area is in square feet.

## `maxBedrooms` (type: `number`):

Optional Zillow search filter. Prices are USD; rental prices are monthly. Living area is in square feet.

## `minBathrooms` (type: `number`):

Optional Zillow search filter. Prices are USD; rental prices are monthly. Living area is in square feet.

## `minSquareFeet` (type: `number`):

Optional Zillow search filter. Prices are USD; rental prices are monthly. Living area is in square feet.

## `maxSquareFeet` (type: `number`):

Optional Zillow search filter. Prices are USD; rental prices are monthly. Living area is in square feet.

## `previousMonitorRunId` (type: `string`):

Optional finished COMPLETE run from this same actor/account with the same query. Overrides autoBaseline for a fixed comparison and does not update the automatic baseline. Leave blank for normal scheduled monitoring. Partial scans are rejected.

## `resumeFromRunId` (type: `string`):

Optional finished run ID from this actor and your account. Copy the full PAGINATION.nextInput to continue from the latest batch. Keep query filters unchanged; change maxResults or advanced limits if needed. Saved rows are skipped. Continuation does not renew the Free allowance or guarantee recovery from a 403.

## `advanced` (type: `object`):

Request, time and download ceilings. Automatic access recovery is included and requires no additional setup.

## Actor input object example

```json
{
  "locations": [
    "Boston, MA"
  ],
  "listingType": "sale",
  "maxResults": 50,
  "autoBaseline": true,
  "minPrice": 10000000
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `summary` (type: `string`):

No description

## `continuation` (type: `string`):

No description

## `errors` (type: `string`):

No description

## `requests` (type: `string`):

No description

## `baseline` (type: `string`):

No description

## `monitorState` (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 = {
    "locations": [
        "Boston, MA"
    ],
    "maxResults": 50,
    "minPrice": 10000000
};

// Run the Actor and wait for it to finish
const run = await client.actor("x_guru/zillow-price-drop-monitor").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 = {
    "locations": ["Boston, MA"],
    "maxResults": 50,
    "minPrice": 10000000,
}

# Run the Actor and wait for it to finish
run = client.actor("x_guru/zillow-price-drop-monitor").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 '{
  "locations": [
    "Boston, MA"
  ],
  "maxResults": 50,
  "minPrice": 10000000
}' |
apify call x_guru/zillow-price-drop-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,x_guru/zillow-price-drop-monitor"
        }
    }
}
```

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/mCFhO9jZI8EYLyDon/builds/I8diQL6RZGi33Q75J/openapi.json