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

🏠 Zillow Detail Scraper pulls property details from Zillow pages—prices, beds/baths, square footage, photos & more. 🚀 Great for real estate lead gen, market research & analytics. ⚡ Save time, automate data collection, and stay ahead.

- **URL**: https://apify.com/scraperoka/zillow-detail-scraper.md
- **Developed by:** [Scraperoka](https://apify.com/scraperoka) (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 $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 🎯 — Extract Property Details at Scale

Manually visiting Zillow property pages one by one to collect structured details wastes hours you don’t have. **Zillow Detail Scraper** automates the extraction of property details directly from Zillow URLs or addresses. This Zillow Detail Scraper for Zillow property data scraper workflows helps marketers, recruiters, and growth teams turn public listing pages into usable datasets—fast. Process many properties in a single run and build lead-ready results in minutes.

***

### What You Get: Sample Output

Here's a sample record from a single run:

```json
{
  "zpid": 49339396,
  "address": "4 Huff Dr, Greenville, SC 29611",
  "buildingUnits": [
    {
      "unitId": "101",
      "address": "4 Huff Dr UNIT 101, Greenville, SC 29611",
      "bedrooms": 2,
      "bathrooms": 1,
      "rentZestimate": 1850,
      "listingSubType": {
        "isForAuction": false
      }
    },
    {
      "unitId": "102",
      "address": "4 Huff Dr UNIT 102, Greenville, SC 29611",
      "bedrooms": 3,
      "bathrooms": 2,
      "rentZestimate": 2250,
      "listingSubType": {
        "isForAuction": false
      }
    }
  ],
  "status": "Sold",
  "listing_sub_type": {
    "is_forAuction": false
  },
  "error_message": null
}
```

**Output Fields (example) — from dataset pushes**

| Field | Type | What It Tells You |
|---|---|---|
| `zpid` | number | The property identifier embedded in the scraped page data |
| `address` | string | Resolved property address (useful for deduping and enrichment) |
| `buildingUnits` | array | Unit-level objects when building unit extraction is enabled and units exist |
| `unitId` | string | Unit identifier inside each building unit object (when available) |
| `bedrooms` | number | Bedroom count (present when Zillow includes it for the unit/property data) |
| `bathrooms` | number | Bathroom count (present when Zillow includes it for the unit/property data) |
| `rentZestimate` | number | Rent estimate shown in the scraped data (when available) |
| `status` | string | Mirrors the `propertyStatus` context you chose for your run (e.g., Sold, For Sale, For Rent) |
| `listing_sub_type` | object | A mapped version of `listingSubType` fields when those exist in the source data |
| `listingSubType` | object | Exists in the source data, but when present is mapped into `listing_sub_type` by the actor output transformation |
| `error_message` | string | Failure-state indicator field (set to `null` on success in typical output workflows) |

Export your dataset as JSON, CSV, or Excel — straight from the Apify dashboard.

***

### Why Zillow Detail Scraper?

There are a lot of ways to pull data from Zillow property pages — here’s what sets **Zillow Detail Scraper** apart.

#### Flexible inputs: URLs or address-based

You can feed Zillow home detail URLs directly in `startUrls`, or provide `addresses` and let the actor resolve them into Zillow home detail links to scrape. This makes it a practical Zillow listing detail extraction workflow when you start from a lead list rather than a URL list.

#### Building unit extraction support

For multi-unit buildings, you can enable extracting unit details from the building page using `extractBuildingUnits`. If units are available and you select a unit-inclusive mode, the actor pushes multiple unit records (instead of only the building-level record), which is ideal for Zillow property details for leads.

#### Robust scraping with retries and resilience

The actor includes retry logic and resilience to improve success rates when pages are temporarily blocked or rate-limited. If it can’t find property data after all retries, it logs that failure for the specific URL rather than silently skipping the page.

#### Output structured for downstream use

Results are pushed to the Apify dataset as JSON objects. The actor also performs a small transformation for `listingSubType` by mapping it into `listing_sub_type`, helping keep the output consistent for Zillow details scraper pipelines and automated enrichment.

***

### Configuring Your Run

Drop this into your `input.json` to get started:

```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_HERE"
}
```

| Parameter | Required | What It Does |
|---|---:|---|
| `startUrls` | ⬜ | A list of Zillow home detail URLs to scrape (each item must include a `url`). |
| `addresses` | ⬜ | A list of addresses to resolve and scrape (example format: `123 Main St, New York, NY`). |
| `propertyStatus` | ⬜ | Sets the status context for properties in your `startUrls` (choose `Sold`, `For Sale`, or `For Rent`). |
| `extractBuildingUnits` | ⬜ | Controls which unit details are extracted from a building page (`Disabled`, `All`, `For Sale`, `Recently Sold`, `For Rent`, `Off Market`). |
| `datasetId` | ⬜ | If provided, the actor reads URLs from this Apify Dataset ID and processes them (it pulls items and uses `url` or `link` fields that contain `zillow.com`). |

***

### Core Capabilities

#### URL and address-based Zillow property scraping

Zillow Detail Scraper supports two common entry points: direct Zillow home detail URLs via `startUrls`, and address-based workflows via `addresses`. This is especially useful for Zillow web scraping software use cases where you start from CRM addresses and need Zillow listing price and address scraper style detail enrichment.

#### Unit-level detail extraction when available

When your target Zillow listing represents a building with units, `extractBuildingUnits` lets you control whether to extract unit details (and how). That enables Zillow listing scraper tool outputs suitable for lead segmentation by unit, not just property.

#### Clean JSON results pushed per scraped item

The actor pushes extracted records to the Apify dataset as it processes each page. When unit extraction is enabled and units exist, it pushes each unit object; otherwise, it pushes the main property object.

#### Uses proxy support for more reliable scraping

The actor is designed to scrape Zillow pages with built-in proxy support for better reliability. If no proxy configuration is created successfully, the actor logs a warning that Zillow will almost certainly return 403.

#### Built-in resilience with retries and fallbacks

It attempts multiple tries per URL (up to 3 retries) and includes fallbacks if the expected page script isn’t present. This helps keep Zillow details scraper runs stable across varied page behavior.

***

### Who Gets the Most Out of This

Here’s how different teams put **Zillow Detail Scraper** to work:

**Real Estate Lead Generation Teams** — Turn lists of Zillow property pages into consistent JSON records, then use the output to build targeted outreach lists. With building unit support, they can segment leads by unit where available.

**Market Researchers & Data Analysts** — Collect Zillow property data scraper outputs for analysis (e.g., unit mix, pricing-related fields, and structured attributes) without writing a custom Zillow extraction script for each new dataset.

**Sales and Outreach Managers** — Use a mix of URL and address inputs to rapidly enrich leads and reduce manual page-by-page work. Outputs from this Zillow HTML scraper style workflow are easy to export and import into internal tooling.

**Automation & Integration Developers** — Ingest the actor’s dataset results into pipelines using the Apify API, then connect it to your downstream systems for automated Zillow listing detail extraction jobs.

**Freelance Researchers** — Deliver structured Zillow property details as a reusable output format for client briefs, especially when clients provide addresses and not URLs.

***

### Step-by-Step: How to Use It

No coding needed. Here's how to run Zillow Detail Scraper from start to finish:

1. **Open the actor on Apify** — go to [console.apify.com](https://console.apify.com) and find **Zillow Detail Scraper**.
2. **Enter your inputs** — choose `startUrls` (Zillow home detail URLs) and/or `addresses` (a list of address strings). Set `propertyStatus` and `extractBuildingUnits` based on what you need.
3. **Configure proxy settings** — enable proxy configuration for better reliability (the actor uses residential proxies by default when available).
4. **Hit Run and watch the live log** — track each URL being processed and see any per-page retry behavior in logs.
5. **View results in the dataset tab** — the actor pushes records as it processes each property (or each unit, when enabled).
6. **Export as JSON, CSV, or Excel** — download the dataset in the format you need for reporting or importing.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, **Zillow Detail Scraper** plugs directly into your existing workflow.

Export formats supported via the Apify dataset UI include JSON, CSV, and Excel, so you can move Zillow property data scraper outputs into Sheets, BI tools, or your CRM.

You can also connect your workflow using Apify programmatic access via the Apify API, and trigger downstream actions using webhooks when runs complete. For no-code automation, you can route results into tools like Zapier or Make, and you can schedule the actor to run automatically for ongoing lead refreshes.

For deeper details on API, exports, and integrations, refer to the Apify documentation at https://apify.com/docs/api.

***

### Pricing & Free Trial

Zillow Detail Scraper runs on the Apify platform, which offers a **free tier** — no credit card required to get started. You can begin with several test runs using the included platform credits on sign-up, then scale based on your workload.

Pay-as-you-go works through Apify’s billing model for compute units (CU), so you only pay for the compute used during your runs rather than a fixed monthly scrape quota. Start for free at [apify.com](https://apify.com) and scale when you're ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Rate limiting | Detects rate-limited responses and waits before retrying |
| Temporary blocks | Retries with resilience and logs failures after all attempts |
| Anti-bot page behavior | Uses a real browser rendering approach so the required page data can load |
| Proxy support | Supports proxy configurations to improve scraping reliability |
| Error visibility | Logs per-URL success/failure so you can assess run quality quickly |

**Limitations:** This actor works with publicly accessible pages. If a page doesn’t provide the expected structured data, the actor may not return a record for that URL after retries.

For enterprise-scale runs, contact us to discuss custom configurations.

***

### Frequently Asked Questions

#### Is there a free plan or trial?

Yes. Apify offers a free tier with platform credits on sign-up, which is enough for several test runs of Zillow Detail Scraper before you scale up.

#### Do I need to log in to Zillow to use this?

No. Zillow Detail Scraper is designed to scrape property details from publicly accessible listing pages, without requiring an account login for the actor.

#### How accurate is the data?

The actor extracts property details from the loaded page data and returns what it can find in the page’s structured content. Accuracy depends on what Zillow provides for each property, including whether building units and unit-level details are present.

#### How many results can I get per run?

The actor processes every URL derived from `startUrls`, every page resolved from `addresses`, and every Zillow URL found from the provided `datasetId`. There’s no hard-coded “max results” in the actor inputs—your practical limit depends on your run size and your Apify plan.

#### How often is the data updated / how fresh is it?

Freshness matches when you run the actor. If you rerun Zillow Detail Scraper against the same URLs or addresses on a new schedule, you’ll get a newly captured snapshot of the current Zillow property details.

#### Is this legal? Does it comply with GDPR / CCPA?

You must ensure your use of the scraped data complies with applicable privacy laws and the platform’s terms. Zillow Detail Scraper only accesses **publicly available data**, and it’s your responsibility to handle it lawfully and responsibly.

#### Can I export results to Google Sheets or Excel?

Yes. You can export from the Apify dataset as JSON, CSV, or Excel, and then import into Google Sheets or other tools as needed. If you’re using automation, you can also connect via Apify integrations and APIs.

#### Can I run this on a schedule automatically?

Yes. You can schedule runs in Apify so Zillow Detail Scraper refreshes listings on a recurring basis, which is useful for ongoing Zillow listing detail extraction and lead refresh workflows.

#### Can I access this via API?

Yes. You can trigger and retrieve results programmatically using the Apify API. For details, see https://apify.com/docs/api.

#### What happens if the actor hits an error?

If the actor can’t load property data for a URL after the retry attempts, it logs that the page failed to scrape after all retries. Results are pushed for successful pages/units during the run, so you keep successful captures even if some pages fail.

***

### Need Help or Have a Request?

Got a question about Zillow Detail Scraper or want a new feature added? Reach out at <dataforleads@gmail.com>. We’re actively maintaining this actor and can help with practical setup questions like inputs, building unit extraction, and export workflows like Zillow listing detail extraction.

If you’d like, we can also discuss ideas such as additional unit modes, improved dataset handling, or tighter integration patterns—tell us what you need.

***

### Disclaimer & Responsible Use

*Zillow Detail Scraper is the fastest, most reliable way to scrape Zillow property details from publicly available pages — start your free run today.*

This actor accesses **publicly available data** from Zillow pages that do not require login. It does not access private accounts, login-gated content, or password-protected pages. You are responsible for ensuring your usage complies with GDPR, CCPA, and applicable platform terms. For data removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# 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("scraperoka/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("scraperoka/zillow-detail-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 '{
  "startUrls": [
    {
      "url": "https://www.zillow.com/homedetails/4-Huff-Dr-Greenville-SC-29611/49339396_zpid/"
    }
  ],
  "addresses": []
}' |
apify call scraperoka/zillow-detail-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scraperoka/zillow-detail-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/l32JSw5i8EQoM7YaV/builds/SUnzGouUHvyBMp1NJ/openapi.json