# Zillow Detail Scraper (`solid-scraper/zillow-detail-scraper`) Actor

Zillow detail scraper to extract comprehensive property details from Zillow listings, including property specifications, pricing, location, features, agent information, and listing metadata 🏡📊 Perfect for real estate market research, investment analysis, property monitoring, and lead generation.

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

## Pricing

from $1.99 / 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.

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 Detail Scraper 🔍

**Zillow Detail Scraper** is a purpose-built tool that scrapes property details from Zillow URLs or addresses—helping you quickly collect structured data for downstream analysis, reporting, or lead workflows. If you’re looking for a **Zillow scraping tool**, **Zillow listing scraper**, or a **Zillow property data scraper** that can handle more than just one page at a time, this actor streamlines the process for you. It’s designed for marketers, real estate researchers, and data analysts who want to automate “scrape Zillow listing details” work at scale—saving you hours of manual effort.

Whether you’re building a Zillow data extraction pipeline, validating listings, or preparing enrichment for a CRM, Zillow Detail Scraper helps you get consistent results from **Zillow detail page scraper** inputs.

***

### 🚀 Why choose Zillow Detail Scraper?

| Feature | Benefit |
| --- | --- |
| ✅ **Scrape by URL or address** | Feed it Zillow home detail URLs or plain addresses to resolve and scrape the matching listings |
| ✅ **Building-unit extraction support** | Pull details for all units on a building page when `extractBuildingUnits` is set to `All` |
| ✅ **Resilient fetching with retries & fallbacks** | Includes retries and handles common access issues by continuing through attempts |
| ✅ **Structured JSON output** | Produces consistent records that are easy to analyze, import, and deduplicate |
| ✅ **Scales across batches** | Uses an input queue so you can process many Zillow listings in one run |
| ✅ **Apify dataset integration** | Optionally reads Zillow URLs from an Apify Dataset ID (`datasetId`) and processes them |

***

### ✨ Key features

- 🔄 **URL and address input support**: Accepts Zillow home detail URLs in `startUrls` and resolves `addresses` into listing URLs for scraping
- 🏢 **Building units extraction (optional)**: With `extractBuildingUnits`, you can extract unit details like a full **Zillow MLS data scraper** workflow when applicable
- 🛡️ **Reliability-focused execution**: Uses robust fetching with retries so runs keep going even when some pages are hard to access
- 📊 **Detail-page property data**: Extracts the relevant property object from the page content for downstream processing
- 💾 **Immediate dataset writing**: Pushes results item-by-item using `charged_event_name="result"` so you can monitor progress and export later
- 🌐 **Dataset-driven mode**: Provide a `datasetId` to read URLs from a previous run and continue scraping without rebuilding your input list

***

### 📝 Input

Provide input via an `input.json` file. Example structure:

```json
{
  "startUrls": [
    {
      "url": "https://www.zillow.com/homedetails/4-Huff-Dr-Greenville-SC-29611/49339396_zpid/"
    }
  ],
  "addresses": [
    "123 Main St, New York, NY"
  ],
  "propertyStatus": "Sold",
  "extractBuildingUnits": "All",
  "datasetId": "YOUR_DATASET_ID"
}
```

#### Input Fields

| Field | Required | Description |
| --- | --- | --- |
| `startUrls` | ❌ | An array of Zillow property URLs to scrape (for example, Zillow home detail links). |
| `addresses` | ❌ | An array of addresses to resolve and scrape (for example, `123 Main St, New York, NY`). |
| `propertyStatus` | ❌ | The current status of the properties you want to scrape. Allowed values are `Sold`, `For Sale`, or `For Rent`. Defaults to `Sold`. |
| `extractBuildingUnits` | ❌ | Controls unit extraction on a building page. Allowed values are `Disabled`, `All`, `For Sale`, `Recently Sold`, `For Rent`, `Off Market`. Defaults to `All`. |
| `datasetId` | ❌ | If provided, the actor will read URLs from this Apify Dataset ID and process them (it looks for items containing `url` or `link`). |

> Tip: A common “Zillow listing scraper” workflow is to run a URL-gathering step first, store the URLs in an Apify dataset, then pass the `datasetId` into Zillow Detail Scraper.

***

### 📦 Output

The actor saves each scraped result as JSON data in the run output dataset. It uses `Actor.push_data(..., charged_event_name="result")` and may push either unit records or the full property record depending on `extractBuildingUnits`.

Sample output items can look like this:

```json
[
  {
    "zpid": "49339396",
    "buildingUnits": [],
    "listing_sub_type": {
      "isFSBO": false,
      "isPending": true
    }
  }
]
```

Or, when unit extraction is enabled and units are present:

```json
[
  {
    "zpid": "49339396",
    "listing_sub_type": {
      "isForAuction": false
    }
  }
]
```

#### Output Fields

Zillow Detail Scraper outputs objects derived from the property data it extracts from the page content. The actor also applies one transformation to produce a `listing_sub_type` field:

| Field | Type | Description |
| --- | --- | --- |
| `listing_sub_type` | object | A mapped version of listing sub-type flags. The actor renames keys from the raw `listingSubType`/`listing_sub_type` structure using an internal mapping (e.g., `isFSBA` → `is_FSBA`, `isPending` → `is_pending`). |
| `listingSubType` | ❌ | Not present in the final output when `listingSubType` exists in the source payload (it is removed after mapping into `listing_sub_type`). |
| `listing_sub_type` (raw) | ❌ | If the raw data includes `listing_sub_type`, it is used to build the mapped `listing_sub_type` in output rather than being kept as-is. |
| `error_message` | ❌ | Not emitted as a distinct field by this actor’s output logic. Failures are logged as “FAILED to scrape … after all retries.” |

> Notes for analysts: the actor pushes `unit` objects when `extractBuildingUnits` is set to `All` and `buildingUnits` (or `units`) are present; otherwise it pushes the full `property_data`. This is why a “Zillow property data scraper” export may include a mix of record shapes depending on whether the page exposes unit listings.

***

### 🚀 How to use Zillow Detail Scraper (via Apify Console)

1. **Open Apify Console**\
   Log in at https://console.apify.com and open the Actors page.

2. **Find Zillow Detail Scraper**\
   Search for the actor titled **Zillow Detail Scraper** and open its listing page.

3. **Go to the INPUT section**\
   Paste your settings into the input editor (or upload an `input.json`).

4. **Choose your input method (URLs or addresses)**\
   Add Zillow home detail URLs under `startUrls`, or add plain addresses under `addresses` (or both).

5. **Set property controls**\
   Pick `propertyStatus` (`Sold`, `For Sale`, or `For Rent`) and choose `extractBuildingUnits` (`Disabled`, `All`, `For Sale`, `Recently Sold`, `For Rent`, `Off Market`).

6. **(Optional) Process URLs from a dataset**\
   If you already have a dataset of Zillow links, set `datasetId` so the actor reads `url` or `link` entries and scrapes those pages.

7. **Click Run and watch logs**\
   During execution, you’ll see progress logs like queue size and per-URL processing. The actor uses retries and resilience logic, and you’ll see “Captcha/automated access detection” alerts in the logs when it can’t extract data.

8. **Open the OUTPUT dataset and export**\
   After the run completes, open the output dataset and export the JSON records (JSON/CSV export options are typically available in Apify’s dataset UI).

No coding required—get automated **Zillow detail page scraper** results in minutes.

***

### 🧠 Advanced features & SEO optimization

- ✅ **Engineered for “scrape Zillow listing details” workflows**: Zillow Detail Scraper is designed for automated Zillow listing scraper use cases where you want structured property records fast, similar to a “Zillow API alternative” approach.
- 🔁 **Retries for resilience**: When pages can’t be accessed or no data can be extracted, the actor continues through attempts instead of failing immediately—helpful for a **Zillow web scraping software** pipeline.
- 🌐 **URL/Address flexibility**: Works with Zillow URLs and also accepts addresses so you can build a “Zillow house data scraper” process without manually converting every input.
- 🧾 **Mapped listing sub-type output**: Converts raw listing sub-type flags into a normalized `listing_sub_type` structure (a practical improvement for analysts working with Zillow MLS data scraper style datasets).

***

### 🎯 Best use cases

- 📈 **Lead generation for real estate outreach**: Scrape Zillow Detail Scraper outputs to populate structured listing datasets for contact and qualification workflows (a strong fit for a Zillow lead generation scraper setup).
- 🏘️ **Property and building portfolio research**: Extract unit-level data from building pages when `extractBuildingUnits` is set to `All`, ideal for a Zillow property data scraper process.
- 🧪 **Data validation and enrichment**: Compare scraped property details against your internal source-of-truth or enrichment pipeline without manual copying.
- 🔎 **Market monitoring and trend analysis**: Build time-based snapshots using Zillow house data scraper exports to track changes in listing inventory and status.
- 🗂️ **Research pipelines for MLS-adjacent datasets**: Use Zillow MLS data scraper style outputs as a supplementary public data source for analysis.
- 💻 **Automation and downstream analytics**: Feed extracted JSON into BI tools or ETL jobs to standardize Zillow listing detail page scraping results at scale.
- ✉️ **Contact-info driven research**: While this actor focuses on property detail extraction, it can still support broader Zillow contact info scraper style research pipelines by providing accurate property identifiers to link with other datasets.

***

### 🧰 Technical specifications

- **Supported Input Formats**
  - ✅ `startUrls`: Zillow home detail URLs (as an array of objects with `url`)
  - ✅ `addresses`: plain address strings (resolved into Zillow listing URLs)
  - ✅ `datasetId`: reads URLs from an Apify Dataset ID and processes them
- **Proxy Support**
  - ✅ Built-in proxy support for reliable scraping (residential proxies are used by default)
- **Retry Mechanism**
  - ✅ Includes retries (configured as `max_retries=3`) for fetching and extraction
- **Dataset Structure**
  - ✅ Each processed result is pushed to the dataset using `charged_event_name="result"`
  - ✅ When `extractBuildingUnits` is `All` and units exist, unit records are pushed individually
- **Limitations**
  - ❌ If the actor detects access blocks or cannot extract property data from the page content, it logs the failure and continues through the batch

***

### ❓ FAQ

#### Can I scrape Zillow property details using addresses instead of URLs?

✅ Yes. You can provide an `addresses` array, and Zillow Detail Scraper resolves those addresses into Zillow listing URLs for scraping.

#### What’s the difference between `startUrls` and `datasetId`?

✅ `startUrls` is a list you provide directly in the actor input. `datasetId` is optional and lets the actor read URLs from an existing Apify dataset so you can chain workflows.

#### How do I extract all building units from a building page?

✅ Set `extractBuildingUnits` to `All`. When the extracted property payload contains `buildingUnits` (or `units`), the actor pushes each unit as its own output record.

#### What values can I use for `propertyStatus`?

✅ The actor accepts `Sold`, `For Sale`, or `For Rent`. The default is `Sold`.

#### What does the actor output?

✅ It outputs JSON objects derived from the extracted Zillow property data. Additionally, it normalizes listing sub-type flags into a `listing_sub_type` field in the final output.

#### Does the output include an `error_message` field?

❌ No. Failures are handled via logging (for example, it logs “FAILED to scrape … after all retries”) rather than emitting an `error_message` field in the dataset items.

#### Is Zillow Detail Scraper usable as a Zillow API alternative?

✅ Many teams use it as a “Zillow API alternative” when they want an automated, structured workflow for scraping property detail page data into their own pipelines.

#### Is this tool legal and compliant to use?

✅ Zillow Detail Scraper works with **publicly accessible sources**, but compliance with laws and platform policies (including GDPR/CCPA considerations and any applicable anti-spam rules) is your responsibility.

***

### 🤝 Support & feature requests

Have questions about Zillow Detail Scraper or want to improve your Zillow scraping tool workflow? We’d love to hear from you. 🚀

- 💡 **Feature Requests**: Ideas we can build next include enhanced export formats for Zillow listing scraper workflows (e.g., more convenient CSV shaping), better filtering options, or additional structured normalization for Zillow property data scraper outputs.
- 📧 **Contact**: For help or requests, email us at <dataforleads@gmail.com>.

Your feedback directly shapes the roadmap for Zillow Detail Scraper.

***

### 🌟 Final thoughts on Zillow Detail Scraper

*If you need an SEO-optimized **Zillow Detail Scraper** for real-world Zillow detail page scraping, this actor is built to help you move from inputs to structured outputs faster.* *Run it at scale and keep your Zillow scraping tool workflow consistent.*

***

### Disclaimer

**This actor only accesses publicly accessible sources.** It does not access private profiles, authenticated data, or password-protected pages.

You are responsible for compliance with applicable laws and regulations (including GDPR and CCPA where relevant), as well as platform terms of service and any applicable rules around data usage and spam. Always use Zillow Detail Scraper responsibly, ethically, and for legitimate purposes.

For data removal requests, contact <dataforleads@gmail.com>.

# Actor input Schema

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

Zillow property URLs to scrape (e.g. https://www.zillow.com/homedetails/...)

## `addresses` (type: `array`):

Zillow addresses to resolve and scrape (e.g. '123 Main St, New York, NY')

## `propertyStatus` (type: `string`):

The current status of the properties you want to scrape.

## `extractBuildingUnits` (type: `string`):

Specify which units to extract from a building page.

## `datasetId` (type: `string`):

If provided, the actor will read URLs from this Apify Dataset ID and process them.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.zillow.com/homedetails/4-Huff-Dr-Greenville-SC-29611/49339396_zpid/"
    }
  ],
  "addresses": [],
  "propertyStatus": "Sold",
  "extractBuildingUnits": "All"
}
```

# 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 = {
    "startUrls": [
        {
            "url": "https://www.zillow.com/homedetails/4-Huff-Dr-Greenville-SC-29611/49339396_zpid/"
        }
    ],
    "addresses": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("solid-scraper/zillow-detail-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 = {
    "startUrls": [{ "url": "https://www.zillow.com/homedetails/4-Huff-Dr-Greenville-SC-29611/49339396_zpid/" }],
    "addresses": [],
}

# Run the Actor and wait for it to finish
run = client.actor("solid-scraper/zillow-detail-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 '{
  "startUrls": [
    {
      "url": "https://www.zillow.com/homedetails/4-Huff-Dr-Greenville-SC-29611/49339396_zpid/"
    }
  ],
  "addresses": []
}' |
apify call solid-scraper/zillow-detail-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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