# Zillow Scraper: Every Listing Past 1,000, Zestimate, Details (`alexmorain/zillow-scraper`) Actor

Scrape every Zillow listing of a city, ZIP code, county or map area (for sale, for rent, sold), past the 1,000-per-search limit, with Zillow's announced count next to the returned count. Home pages by zpid or URL, new-listing and price-change watch.

- **URL**: https://apify.com/alexmorain/zillow-scraper.md
- **Developed by:** [Alexis Morain](https://apify.com/alexmorain) (community)
- **Categories:** Real estate, Lead generation, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 93.3% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 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/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 Scraper: scrape every Zillow listing of a city, ZIP code or map area

Zillow Scraper exports the listings that [Zillow](https://www.zillow.com) shows for a city, a ZIP code, a county, a neighborhood or a rectangle on the map: homes for sale, homes for rent and recently sold homes. One Zillow search serves 984 listings at most, however many it announces. This actor cuts the map into smaller cells until each one fits under that limit, reads them all, removes the duplicates on the borders and returns one row per listing, with the price, address, coordinates, beds, baths, living area, Zestimate, days on Zillow and brokerage.

It works as a **Zillow API alternative** for people who need rows, not a website: no login, no browser, plain HTTP. Results land in a dataset you can export as JSON, CSV, Excel or XML, or read through the Apify API from Python, JavaScript or cURL. Each run also writes a proof in its SUMMARY record: the count Zillow announced next to the count you received.

If you only need a handful of homes, give it zpids or home page URLs and it returns the full home page data of each one.

#### How to scrape more than 1,000 Zillow listings

Zillow's search pages stop at page 24 with 41 listings each, so 984 rows. Ask for Houston and Zillow says "15,361 results", then serves 984 of them. The table compares what Zillow announced with what this actor returned, for-sale listings, full coverage on, runs of 1 November 2026.

| Area | Zillow announces | One Zillow search | This actor | Run time | Run |
|---|---|---|---|---|---|
| Austin, TX (map box) | 6,029 | 984 | 6,029 | 49 s | `Dzft0FXGd4FDJXkO3` |
| Houston, TX | 15,361 | 984 | 15,361 | 2 min 36 s | `3B6hnDvkHvKYINFw8` |
| Denver, CO | 3,772 | 984 | 3,772 | 60 s | `9BZBUGnwCLn45i7VY` |

With full coverage off, the actor returns Zillow's 984 and says so in the status message: "Zillow serves at most 984 listings per search; 2788 of the 3772 announced were not returned" (Denver again, run `0bOmQj2qCYXPqQ3Sz`). The Austin run shows how much cleaning the borders need: 246 listings were served twice and returned once.

The SUMMARY record of the Denver run, trimmed to the fields that carry the proof:

```json
{
  "listingsReturned": 3772,
  "inputs": [{
    "input": "Denver, CO",
    "announcedByZillow": 3772,
    "uniqueListingsFound": 3772,
    "announcedInLeafCells": 3772,
    "servedInLeafCells": 3772,
    "duplicatesSkipped": 123
  }]
}
```

`announcedInLeafCells` is the sum of the counts Zillow gave for each map cell the actor read in full. `servedInLeafCells` is how many distinct listings those cells served. When the two match, nothing is missing. When they do not, the actor splits that cell again, and what is still short after that is reported as `cellsStillOverLimit`.

### Why use a Zillow scraper

A market study of one metro area, a lead list of every listing in a ZIP code or a price model trained on a city needs the whole area, not the first 984 rows of a sort order.

- **Investors, analysts and researchers**: every home of an area with price, size, Zestimate, days on Zillow and coordinates, for a spreadsheet, a notebook or a price model.
- **Agents, brokers and wholesalers**: a daily feed of the listings that appeared since the last run, or whose price moved.
- **PropTech teams**: complete, deduplicated rows for a database, or specific homes read by zpid.
- **Rental watchers**: rentals by ZIP code, with apartment buildings kept as one row each.

What you get on top of a plain search export:

- Full coverage past 984, with the announced count against the returned count in every run.
- Duplicates removed before they are charged.
- Optional home page data per listing: description, year built, price history when Zillow shows it, all photos, HOA fee, parking, agent and MLS details.
- A watch mode that returns only new listings, or new listings plus price changes, with the previous price.
- Residential US proxies included in the price, and Apify scheduling, API access and integrations (Make, Zapier, n8n, Google Sheets).

### How to scrape Zillow listings, step by step

1. Open the actor in Apify Console and go to the Input tab.
2. In **Places**, type what you would type in Zillow's search box: `Austin, TX`, `78701`, `Travis County, TX` or `Hyde Park, Austin, TX`. Each place is read separately.
3. Pick **For sale**, **For rent** or **Sold**, and add filters if you want a subset.
4. Set **Max items**. Use 100 for a first test. Empty means the whole area, tens of thousands of listings for a large city.
5. Turn on **Read each home page** if you need the home page data. Leave **Full coverage** on to get more than 984 rows.
6. Click **Start**. The status message ends with the announced count against the returned count.
7. Download the dataset from the Output tab as JSON, CSV or Excel, or read it through the API.

Already have a search on zillow.com? Copy its URL into **Zillow search URLs**: when it carries `searchQueryState` (as soon as you moved the map or set a filter), the actor reads the region, the map and the filters from it.

### Scrape Zillow by ZIP code, city, county, map area or zpid

You can mix inputs in the same run. Each one gets its own entry in the SUMMARY record and its own status.

#### Places (`locations`)

City and state, ZIP code, county or neighborhood, as Zillow's autocomplete knows it. The actor asks Zillow's autocomplete for the place, then reads the region outline from the search page, so a city search returns the city and not the rectangle around it. Austin by outline is 5,548 listings, while the same map box without the outline holds 9,760.

A place Zillow does not recognize ends as `not-found`, and the status message names it. Zillow answers garbage with a region (it sent "zzzzqqxx" to San Diego), so the actor only accepts a region that the autocomplete itself recognized.

#### Zillow search URLs (`startUrls`)

A search page copied from zillow.com. If it carries `searchQueryState`, the map, region and filters are used as they are, including the for sale, for rent or sold type. A plain page such as `https://www.zillow.com/austin-tx/rentals/` gives its region and its rent or sold type, and filters you set in the input fields are added on top. Filters written inside the URL path, such as `/3-_beds/`, are not read: use the input fields for those.

#### Map area (`area`)

A rectangle with north, south, east and west, for an area that no place name covers, for example `{"north": 30.50, "south": 30.15, "east": -97.55, "west": -97.95}`. The whole rectangle is read, with no region outline.

#### Homes by zpid or URL (`zpidsOrUrls`)

A zpid (`64625418`) or a home page URL (`https://www.zillow.com/homedetails/.../64625418_zpid/`). Each one returns the full home page row and is charged as a detailed listing. This is the mode for pipelines that already hold a list of zpids, for example after an address match. A zpid that does not exist on Zillow is named in the status message.

#### Full coverage and home page details

**Full coverage** is on by default. The map is cut into four cells, then each cell that announces more than 800 listings is cut again, up to 12 levels deep. A cell that is already very small and still overflows, such as a dense block of condos, is split into price bands inside the price range you set. With **Max items** set, the actor reads the cells breadth first, so a limit of 300 spreads over the area instead of filling one corner.

**Read each home page** (`includeDetails`) opens the Zillow home page of each listing and adds the home page fields to its row. The row is charged as a detailed listing instead of a plain one, not on top of it. If a home page cannot be read, the row keeps the search fields, `detailsStatus` says `failed`, `not-found` or `timeout`, and it is charged as a plain listing. Apartment buildings have no home page and stay plain rows.

### Scrape Zillow for sale, for rent and sold homes

For sale is the default. Set **Listing type** to For rent or Sold, or paste a search URL that already has the type.

- **For rent**: `price` is the monthly rent, and `minPrice` and `maxPrice` apply to it. Zillow lists an apartment building as one card with several units. The actor returns it as one row with `isBuilding` true, no zpid, a `buildingId`, a `unitCount` and a `units` array (price starting at, and bedrooms, per unit type). The count Zillow announces for rentals counts units, so it is higher than the number of rows.
- **Sold**: rows have `homeStatus` RECENTLY_SOLD and `dateSold`. In states that do not disclose the sale price (Texas is one), Zillow shows no price for sold homes, so `price` comes back null. The date is there, the price is not.

#### Filters

Each filter was checked against Zillow by comparing the total of the same map box with and without it.

| Field | What it does |
|---|---|
| `minPrice`, `maxPrice` | Price for sale and sold, monthly rent for rentals |
| `minBeds`, `maxBeds` | Bedrooms. Set both to 0 for studios only |
| `minBaths` | Bathrooms, halves count as .5 |
| `homeTypes` | house, townhouse, condo, apartment, multiFamily, lot, manufactured |
| `daysOnZillow` | 1, 7, 14, 30, 90, 6m, 12m, 24m or 36m. For sold homes it is the sale window |

For rent, Zillow serves houses, townhouses and apartments or condos, and treats condo and apartment as linked. The actor stops with a clear message if you ask for lots, manufactured homes or multi-family in rent, because Zillow does not apply them to rentals and returns everything for multi-family. Sorting by price is not offered: it did not hold up when checked.

### What data does the Zillow scraper extract?

A search row carries the identity, address, price, size, Zestimate, status, brokerage, photos and coordinates. With home pages on, or when you read homes by zpid, the row also gets the home page fields. Fields that Zillow does not show for a given home come back as null, so every row has the same keys. The full list, from the dataset schema:

| Field | Type | Description |
|---|---|---|
| `zpid` | number | Zillow property ID. Null for apartment buildings (see buildingId) |
| `url` | string | Listing page on Zillow |
| `listingType` | string | forSale, forRent or sold, as searched |
| `homeStatus` | string | Zillow status: FOR_SALE, FOR_RENT, RECENTLY_SOLD, PENDING... |
| `statusText` | string | Status as shown on the card. Empty when a home is read by zpid or URL (no search card) |
| `homeType` | string | SINGLE_FAMILY, CONDO, TOWNHOUSE, MULTI_FAMILY, APARTMENT, LOT, APARTMENT_BUILDING... |
| `price` | number | List price, or monthly rent for rentals. Null for sold homes in states that hide the sale price (Texas) and for buildings |
| `currency` | string | Currency code |
| `streetAddress` | string | Street address |
| `city` | string | City |
| `state` | string | State code |
| `zipcode` | string | ZIP code |
| `latitude` | number | Latitude |
| `longitude` | number | Longitude |
| `beds` | number | Bedrooms |
| `baths` | number | Bathrooms (halves count as .5) |
| `livingArea` | number | Living area in square feet |
| `lotAreaValue` | number | Lot size, in lotAreaUnit |
| `lotAreaUnit` | string | acres or sqft |
| `zestimate` | number | Zillow's estimated market value, when Zillow shows one |
| `rentZestimate` | number | Zillow's estimated monthly rent, when shown |
| `taxAssessedValue` | number | Tax-assessed value |
| `daysOnZillow` | number | Days since the listing appeared on Zillow |
| `dateSold` | string | Sale date (YYYY-MM-DD) for sold homes |
| `brokerName` | string | Listing brokerage |
| `imgSrc` | string | Main photo |
| `photos` | array | Photo URLs (all photos of the listing page with home pages on, else the search carousel) |
| `isBuilding` | boolean | True for an apartment building row (rentals): no zpid, one row per building |
| `buildingId` | string | Building ID, only for building rows |
| `unitCount` | number | Available units of a building |
| `units` | array | Unit types of a building: price (monthly, starting at) and beds |
| `has3DModel` | boolean | Zillow 3D tour available |
| `hasVideo` | boolean | Video available |
| `searchInput` | string | What you entered: the place, search URL, area or home this row comes from |
| `scrapedAt` | string | ISO timestamp of the read |
| `previousPrice` | number | Monitoring: price returned by the previous run for this listing, null for a new listing |
| `priceChange` | string | Monitoring: new, up or down |
| `detailsStatus` | string | With home pages on: ok, failed, not-found or timeout. A failed read is charged as a plain listing |
| `description` | string | Listing description (home page) |
| `yearBuilt` | number | Year built (home page) |
| `priceHistory` | array | Price and status events: date, price, event, source (home page). Null when Zillow serves the page template without history (see priceHistoryAvailable), which depends on the home, not on the run |
| `priceHistoryAvailable` | boolean | Home page read: true when Zillow served a price history (it may be an empty list), false when its page template carries none |
| `monthlyHoaFee` | number | Monthly HOA fee (home page) |
| `parking` | array | Parking features (home page) |
| `parkingSpaces` | number | Parking capacity (home page) |
| `cooling` | array | Cooling systems (home page). Filled on rentals, usually null on sale pages |
| `pricePerSquareFoot` | number | Price per square foot (home page) |
| `agentName` | string | Listing agent (home page, when the listing shows one) |
| `agentPhone` | string | Listing contact phone, the listing agent's line (home page, when shown) |
| `brokerPhone` | string | Brokerage phone (home page, only when Zillow gives one apart from the agent line) |
| `mlsId` | string | MLS number (home page) |
| `mlsName` | string | MLS name (home page) |
| `datePosted` | string | Date the listing was posted (YYYY-MM-DD, home page, when shown) |
| `pageViewCount` | number | Zillow page views (home page, when shown) |
| `favoriteCount` | number | Zillow saves (home page, when shown) |

A few columns are empty by nature. `priceHistory` depends on the page template Zillow serves for that home (see the limits), `price` is empty for sold homes in states that do not disclose the sale price, and `statusText` is empty when you read a home by zpid, because a home page has no search card.

#### Example row from a search

A real row from a search run on ZIP code 78701, 1 November 2026, with the photo list shortened to one URL:

```json
{
  "zpid": 339448049,
  "url": "https://www.zillow.com/homedetails/44-East-Ave-UNIT-1208-Austin-TX-78701/339448049_zpid/",
  "listingType": "forSale",
  "homeStatus": "FOR_SALE",
  "statusText": "Active",
  "homeType": "CONDO",
  "price": 231288,
  "currency": "USD",
  "streetAddress": "44 East Ave Unit 1208",
  "city": "Austin",
  "state": "TX",
  "zipcode": "78701",
  "latitude": 30.255808,
  "longitude": -97.739,
  "beds": 2,
  "baths": 2,
  "livingArea": 793,
  "zestimate": null,
  "taxAssessedValue": 221850,
  "daysOnZillow": 68,
  "brokerName": "HomeBase",
  "photos": ["https://photos.zillowstatic.com/fp/dfff9bba8c9fbd2d2d5247215e45d7b4-p_e.jpg"],
  "isBuilding": false,
  "searchInput": "78701",
  "scrapedAt": "2026-11-01T05:13:20+00:00"
}
```

#### Example row with home page details

A real row with **Read each home page** on (run `a88mqWJ0Wh5adCUxf`), some search fields left out and the description and price history shortened. This home has a price history, and `priceHistoryAvailable` says so:

```json
{
  "zpid": 89552472,
  "streetAddress": "360 Nueces St APT 1301",
  "price": 395000,
  "livingArea": 801,
  "description": "13th-floor end unit with panoramic Downtown Austin views and Lady Bird Lake. ...",
  "yearBuilt": 2008,
  "priceHistory": [
    {"date": "2026-10-16", "price": 395000, "event": null, "source": null},
    {"date": "2026-09-16", "price": 429000, "event": null, "source": null}
  ],
  "priceHistoryAvailable": true,
  "monthlyHoaFee": 704,
  "parking": ["Assigned", "Covered", "Reserved"],
  "pricePerSquareFoot": 493,
  "mlsId": "3418824",
  "detailsStatus": "ok"
}
```

### Zillow price drop tracker: monitor new listings and price changes

Set **Monitoring** to get a feed instead of a full export.

- **New listings only** returns the listings that no earlier run with the same input returned.
- **New listings and price changes** also returns listings whose price moved, with `previousPrice` and `priceChange` (up or down). Listings new to the watch get `priceChange` new.

The first run returns everything. After that, unchanged listings are not pushed and not charged. Zillow's search order is not by date, so a watch always reads the whole area and compares it with its memory.

The memory lives in a named key-value store in your account called `zillow-scraper-monitor`, one record per search input and per watch. Runs that share the same input and the same **Monitor name** share one memory; change the name to start a second, separate watch on the same search. A listing joins the memory only after it was delivered, so one cut by Max items or by the maximum charge comes back in the next run. Entries older than 180 days are forgotten.

A test on ZIP code 78701, 1 November 2026: the first run returned 198 listings, the second returned 19 new listings, 1 price increase and 1 price drop, and left out 196 unchanged (runs `TVhhVdLgtgguavT13` and `I0bYCWGym0ha6Sryk`).

To schedule it, open Schedules in Apify Console, pick the actor, paste the input and set a cron expression. A daily run at 7:00 with Monitoring on gives you what changed since yesterday.

**Webhook.** Set **Webhook URL** to get a POST at the end of the run, only when it returned at least one row. The JSON body carries `actor`, `runId`, `datasetId`, `monitorMode`, `items`, `byEvent`, `inputs`, plus a one-line message in `text` (Slack) and `content` (Discord). A webhook that fails is logged and does not fail the run.

### How much does it cost to scrape Zillow?

The actor uses Apify's pay-per-event pricing. You pay for events, and the residential proxy that Zillow requires is included.

| Event | Charged when | Free | Bronze | Silver | Gold, Platinum, Diamond |
|---|---|---|---|---|---|
| Listing | A unique listing is returned from a search | $1.00 per 1,000 | $0.87 | $0.73 | $0.50 |
| Detailed listing | A listing is returned with its home page data, or a home is read by zpid or URL. Charged instead of Listing | $2.50 per 1,000 | $2.20 | $1.85 | $1.60 |
| Actor start | The run starts, per GB of memory (256 MB by default) | $0.002 | $0.002 | $0.002 | $0.002 |

The plan tier is the one of your Apify subscription. A listing found twice in a run is charged once. A listing skipped by the watch because it was already returned is not charged. A home page that could not be read is charged as a plain listing.

Example: a search that returns 10,000 listings, 1,000 of them with their home page (9,000 Listing events and 1,000 Detailed listing events).

That costs $11.50 on Free (9,000 x $0.00100 + 1,000 x $0.00250), $10.03 on Bronze, $8.42 on Silver and $6.10 on Gold, start event not included.

Other examples at the Free rate: Houston, all 15,361 for sale listings, about $15.36; a daily watch that sees 20 new listings a day, about $0.022 a run. To keep a test cheap, set **Max items** or the maximum charge per run in the run options: at the maximum charge the actor stops and keeps the rows it already read.

### Scrape Zillow with Python, JavaScript or cURL

These examples use the actor `alexmorain/zillow-scraper`. Replace the token with your own and keep it in an environment variable.

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("alexmorain/zillow-scraper").call(run_input={
    "locations": ["Austin, TX", "78701"],
    "listingType": "forSale",
    "minPrice": 300000,
    "maxPrice": 900000,
    "minBeds": 2,
    "homeTypes": ["house", "condo"],
    "daysOnZillow": "30",
    "maxItems": 2000,
})

for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["streetAddress"], row["price"], row["zestimate"])

summary = client.key_value_store(run["defaultKeyValueStoreId"]).get_record("SUMMARY")["value"]
for entry in summary["inputs"]:
    print(entry["input"], entry["announcedByZillow"], entry["uniqueListingsFound"])
```

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('alexmorain/zillow-scraper').call({
    locations: ['Denver, CO'],
    listingType: 'forRent',
    minPrice: 1500,
    maxPrice: 2500,
    maxItems: 500,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length, 'rows,', items.filter((r) => r.isBuilding).length, 'buildings');
```

#### cURL

Start a run and wait for the rows in one call:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/alexmorain~zillow-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"zpidsOrUrls": ["64625418", "https://www.zillow.com/homedetails/x/89552472_zpid/"]}'
```

A synchronous call times out after five minutes: use it for short runs. For a whole city, start the run with `POST /v2/acts/alexmorain~zillow-scraper/runs` and read the dataset when it ends.

### Limits of this Zillow scraper, written plainly

- **United States only.** A place outside the US ends as not found.
- **Price history is missing on part of the home pages.** Zillow serves two templates for a home page. One carries the price history, the other does not, and the home decides which one you get, not the run or the IP. In a sample of 10 homes in ZIP code 78701, 2 had a history and 8 did not (run `a88mqWJ0Wh5adCUxf`); a check of 10 other homes found 4 with history (6, 5, 15 and 17 events) and 6 without (run `uMsfDvfAc29RlBkZe`). The history of the other template sits behind a call that only Zillow's own pages may make, so the actor cannot get it. `priceHistoryAvailable` tells you which rows have one.
- **Sold homes have no price in states that do not disclose it**, such as Texas. The row keeps `dateSold` and the rest.
- **For rent, the announced count is a count of units.** In ZIP code 78701, with rent from $1,500 to $2,500, Zillow announced 78 units and the actor returned 24 rows, 13 of them buildings (run `y1EWkS1ILc0oiuY2q`). The returned count is lower than the announced count by design, and `buildingRows` in the SUMMARY tells you how many rows are buildings.
- **Not extracted**: tax history, nearby schools, Zestimate history, mortgage data, agent directories. The home page request this actor reads does not return them, so there is no column for them.
- **Zillow can refuse requests.** The actor changes IP after a refusal and every 40 requests, and retries. If Zillow refuses everywhere, the run ends FAILED with a message instead of returning a half empty dataset. A single input that fails does not stop the others.

### Zillow scraper FAQ

#### How to scrape more than 1,000 listings from Zillow?

A Zillow search serves 984 listings at most (24 pages of 41), whatever the announced total. To get more, the map has to be split into smaller searches, each under the limit, and the results merged without duplicates. That is what full coverage does. Houston announced 15,361 listings and the actor returned 15,361 (run `3B6hnDvkHvKYINFw8`).

#### Can I scrape Zillow by ZIP code?

Yes. Type the ZIP code in **Places**, for example `78701`. ZIP codes are read with Zillow's region outline, so you get that ZIP code and not the neighbors. ZIP code 78701 for sale had 217 listings on 1 November 2026 and the actor returned 217 in 25 seconds (run `eSYdwPLeOzztzX5Ef`). You can pass many ZIP codes in the same run.

#### Do I get the Zillow price history of every home?

No, and the reason is on Zillow's side. With home pages on, the actor returns `priceHistory` (date, price, event and source for each event) for the homes whose page carries it. Zillow serves a second page template without a price history for part of the homes. `priceHistoryAvailable` tells you, for every row, whether Zillow gave one.

#### How do I track Zillow price changes?

Set **Monitoring** to New listings and price changes, schedule the run, and read `priceChange` and `previousPrice` on each row. See the monitoring section above.

#### Is it legal to scrape Zillow?

This is not legal advice. The data this actor reads is what Zillow shows to any visitor of its public pages: no login, no private account data. Whether collecting it is allowed depends on what you do with it, where you are and Zillow's terms of use, which limit automated access and the reuse of its content. Read them before building a product on the data. The listing data also contains personal data: the name and phone number of listing agents. In the European Union the GDPR applies to it, and in the US state privacy laws and rules about unsolicited calls and texts may apply. Do not use agent contacts for mass cold calling or messaging, keep only what you need, and ask a lawyer if the use is commercial and at scale.

#### How does this compare to an official Zillow API?

This actor does not use an official Zillow API. It reads the public site and gives you the rows a visitor would see, in a dataset or through the Apify API. It is a scraper, so it depends on the site's structure and on Zillow's protections, and you should expect to rerun or adjust if Zillow changes them.

### Disclaimers and support

Our actors do not extract private user data such as email addresses or the location of users. They only extract what Zillow shows publicly. Your results can still contain personal data, such as the name and phone number of a listing agent. Personal data is protected by the GDPR in the European Union and by other regulations around the world. Do not scrape personal data unless you have a legitimate reason, and if you are unsure whether yours is legitimate, consult a lawyer. This actor is not affiliated with or endorsed by Zillow.

Something wrong or missing? Use the Issues tab of this actor. Send the run id and the input. The API tab has the endpoints and ready-made code to start the actor from your own tools.

### Guide and use cases

Use cases for outbound and automation, the output fields, pricing and common questions are on the [Zillow Scraper page](https://alexis.morain.fr/en/scrapers/zillow-scraper/) of my site. The [Classifieds and real estate family page](https://alexis.morain.fr/en/scrapers/families/classifieds-real-estate/) puts it side by side with the other scrapers of the same family.

# Actor input Schema

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

City, ZIP code, county or neighborhood, as you would type it on Zillow: <code>Austin, TX</code>, <code>78701</code>, <code>Travis County, TX</code>, <code>Hyde Park, Austin, TX</code>. Zillow's own outline of the place is used, so a city search returns the city, not the box around it. US places only.

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

Search pages copied from zillow.com. When the URL carries <code>searchQueryState</code> (any search where you moved the map or set filters), its map, region and filters are used as they are. A plain page such as <code>https://www.zillow.com/austin-tx/rentals/</code> gives its region and rent / sold type; filters written in the path (<code>/3-\_beds/</code>) are not read, use the fields below.

## `area` (type: `object`):

A drawn rectangle: <code>{"north": 30.50, "south": 30.15, "east": -97.55, "west": -97.95}</code>. Use it for an area no place name covers; the whole rectangle is read.

## `zpidsOrUrls` (type: `array`):

Homes to read one by one: a zpid such as <code>64625418</code> or a URL such as <code>https://www.zillow.com/homedetails/.../64625418_zpid/</code>. Each one returns the full home page and is charged as a Detailed listing. Meant for pipelines that already hold a list of zpids.

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

Applies to places and map areas. A search URL keeps its own type (for sale, for rent or sold).

## `minPrice` (type: `integer`):

In US dollars. The price for sale and sold homes, the monthly rent for rentals.

## `maxPrice` (type: `integer`):

In US dollars. The price for sale and sold homes, the monthly rent for rentals.

## `minBeds` (type: `integer`):

0 for no minimum.

## `maxBeds` (type: `integer`):

Set both to 0 for studios only.

## `minBaths` (type: `integer`):

Bathrooms, halves count as .5. 0 for no minimum.

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

Leave empty for all types. For rent, Zillow serves houses, townhouses and apartments / condos (the two are linked); lots, manufactured homes and multi-family are for sale and sold only.

## `daysOnZillow` (type: `string`):

Only listings that appeared on Zillow (or, for sold homes, sold) within this window. Leave empty for no limit.

## `fullCoverage` (type: `boolean`):

Zillow shows at most 984 listings per search, whatever the announced count (Austin announces 16,850). On, the map is split into smaller and smaller cells until each one fits, so every listing is returned and the SUMMARY record shows announced against returned. Off, you get Zillow's 984 and a note on how many are missing.

## `includeDetails` (type: `boolean`):

Adds description, year built, price history when Zillow shows it, all photos, HOA fee, parking, agent and MLS details to each listing (Detailed listing event, higher price). Apartment buildings have no home page and stay plain listings.

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

Stops after this many listings in total. Empty or 0 = every listing of the area: tens of thousands for a large city, so set a limit or a maximum charge per run when you test.

## `monitorMode` (type: `string`):

<b>New listings only</b> returns only listings not returned by an earlier run with the same input (and monitor name). <b>New and price changes</b> also returns listings whose price moved, with <code>previousPrice</code> and <code>priceChange</code> (up / down). Unchanged listings are neither returned nor charged. The first run returns everything. State is kept in a store named <code>zillow-scraper-monitor</code> in your account.

## `monitorName` (type: `string`):

Optional. Runs with the same name and the same input share one memory; change it to start a separate watch on the same search.

## `webhookUrl` (type: `string`):

Optional. A JSON summary is POSTed here when the run ends with at least one listing. Slack and Discord incoming webhooks work. Redirects are not followed (except 307 / 308).

## Actor input object example

```json
{
  "locations": [
    "78701"
  ],
  "listingType": "forSale",
  "fullCoverage": true,
  "includeDetails": false,
  "maxItems": 1000,
  "monitorMode": "off"
}
```

# Actor output Schema

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

All listings in the default dataset.

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

Status of each place, search URL, area or home: listings returned, count announced by Zillow, listings served by the map cells, cells read, pages read, duplicates skipped, listings skipped by monitoring, requests, refusals and IP rotations.

# 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": [
        "78701"
    ],
    "maxItems": 1000
};

// Run the Actor and wait for it to finish
const run = await client.actor("alexmorain/zillow-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 = {
    "locations": ["78701"],
    "maxItems": 1000,
}

# Run the Actor and wait for it to finish
run = client.actor("alexmorain/zillow-scraper").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": [
    "78701"
  ],
  "maxItems": 1000
}' |
apify call alexmorain/zillow-scraper --silent --output-dataset

```

## MCP server setup

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

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/dDbB2YG7i4LPK1RgC/builds/GPzayKE5q6Rs3V23v/openapi.json
