# Zillow Real-Time Property & Agent Data Scraper (`b2b_leads/zillow-real-time-data-scraper`) Actor

Scrape Zillow in real time: search any location, get full property details, prices, beds/baths, year built, taxes, schools, and agent contacts — clean, normalized phone numbers and agent IDs. Results stream to your dataset as JSON with webhooks and proxy rotation built in.

- **URL**: https://apify.com/b2b\_leads/zillow-real-time-data-scraper.md
- **Developed by:** [Emmanuel](https://apify.com/b2b_leads) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 results

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 Real-Time Data — Property & Real-Estate Lead Data at Scale

**Turn Zillow listings into clean, structured property and lead data.** Give it one or more locations — or specific listing URLs — and get one flat JSON row per property, complete with price, home facts, taxes, HOA, schools, days on market, listing agent, and (optionally) enriched lead contact details. Rows stream into your Apify dataset **as they are collected**, so even very long runs stay light and nothing is lost mid-run.

No Zillow API keys. No spreadsheets. No cleanup. Just enter locations and press **Start**.

> ⚡ **Real-time streaming output** • 🎯 **Multi-location runs** • 🧩 **Flat, predictable JSON** • 🤝 **Lead details without filtering** • 💸 **Pay only for what you export**

***

### ✅ Pricing & free-plan note (read first)

This Actor uses Apify's **pay-per-result** model — you're charged per exported row (see [Pricing](#pricing)).

- **Apify free plan:** runs are limited to a **2-result sample** per run, and the log tells you to upgrade. This is an Apify platform plan restriction, applied transparently — it is not an error.
- **Any paid Apify plan (Bronze and above):** full, uncapped output. You get exactly what your input asks for.
- Every run also honors your **max run charge** (spending limit): the Actor finishes gracefully the moment your configured limit is reached.

Details: [Free plan limitations](#free-plan-limitations) · [Pricing](#pricing)

***

### Why this Actor

| | Zillow Real-Time Data | Typical scraper |
|---|---|---|
| **Speed** | Fast per-result collection | Often slow & fragile |
| **Memory** | **512 MB** default | 2–4 GB+ |
| **Setup** | Organized input UI — run immediately | Often needs tuning |
| **Output** | Flat, stable JSON field names | Messy, inconsistent |
| **Streaming** | Rows saved live during the run | Results only at the end |
| **Scale** | Up to **50,000 rows** per run | Often capped much lower |
| **Freshness** | Collected at run time ("real-time") | Cached or stale |

***

### What you get — 80+ data points per property

Every property row includes `featureType` and `scrapedAt` so you can filter, join, and pipe into any workflow.

#### Property rows (`featureType: "search"` / `"property_details"`)

| Group | Fields |
|-------|--------|
| **Identity** | `zpid`, `propertyUrl`, `address`, `streetAddress`, `city`, `state`, `zipCode`, `neighborhood`, `county` |
| **Status & type** | `propertyType`, `propertySubType`, `listingType`, `listingStatus`, `homeStatus` |
| **Pricing** | `price`, `pricePerSqFt`, `zestimate`, `rentZestimate`, `originalPrice`, `priceChange`, `priceChangePercent`, `daysOnZillow` |
| **Home facts** | `bedrooms`, `bathrooms`, `fullBathrooms`, `halfBathrooms`, `squareFeet`, `lotSize`, `lotSizeUnits`, `yearBuilt`, `yearRenovated`, `stories`, `rooms`, `floors` |
| **Location** | `latitude`, `longitude`, `timezone`, `walkScore`, `transitScore`, `bikeScore` |
| **Features** | `heating`, `cooling`, `parking`, `garageSpaces`, `hasPool`, `hasView`, `hasWaterfront`, `isNewConstruction`, `isForeclosure`, `isAuction`, `isComingSoon`, `isForSaleByAgent`, `isForSaleByOwner`, `isPending`, `isBankOwned`, `isOpenHouse`, `isVirtualTour`, `is3dHome`, `isHomeStage` |
| **Media** | `mainImage`, `images[]`, `imageCount` |
| **Schools** | `schoolDistrict`, `elementarySchool`, `middleSchool`, `highSchool`, `schoolRating`, `schoolDistance` |
| **Tax & HOA** | `taxAssessedValue`, `taxAnnualAmount`, `taxYear`, `hoaFee`, `hoaFrequency` |
| **Description** | `description`, `features[]`, `amenities[]` |
| **History** | `lastSoldDate`, `lastSoldPrice`, `previousListings[]`, `nearbySales[]` |
| **Listing agent** | `agentId`, `agentName`, `agentPhone`, `agentEmail`, `agentUrl`, `brokerageName`, `agentContact` |

#### Agent profile rows (`featureType: "agent_details"`)

| Group | Fields |
|-------|--------|
| **Identity** | `agentId`, `agentName`, `agentTitle`, `agentUrl`, `profileImageUrl` |
| **Contact** | `email`, `phone`, `phoneNumbers[]`, `fax`, `website` |
| **Social** | `socialMedia` (facebook, twitter, linkedin, instagram, youtube, tiktok, pinterest) |
| **License** | `licenseNumber`, `licenseState`, `licenseExpiration`, `yearsExperience` |
| **Brokerage** | `brokerageName`, `brokerageUrl`, `brokeragePhone`, `brokerageAddress` |
| **Service area** | `serviceAreas[]`, `officeAddress`, `officeCity`, `officeState`, `officeZip` |
| **Performance** | `recentSales`, `activeListings`, `averageRating`, `reviewCount`, `specializations[]`, `languages[]` |

***

### Features

#### 🔎 Search — multi-location property search

Add any number of locations (city, state, or ZIP) and collect up to N properties per location. Pick the listing status: **for sale** (default), **for rent**, **sold**, **pending**, or **all**. Optional result filters: minimum/maximum price, minimum/maximum bedrooms, minimum bathrooms.

#### 🏠 Full property details (on by default)

Every property is enriched with description, taxes, HOA, schools, days on market, features, history, and the listing agent. Adds a little extra time per business.

#### 🤝 Enable lead details (on by default) — enrichment, never a filter

Adds lead contact details to each property — agent name, phone, email, website, and social profiles — **when they are available**.

**Every property is still exported even when no lead details are found.** Nothing is ever dropped for lacking contact info, so the time and cost of a run stay predictable (this is deliberate: you always know what a run of N businesses costs).

#### 🕵️ Agent profiles

Paste agent profile URLs and collect complete agent records as their own rows — ideal for building real-estate contact lists.

#### 📎 Property URLs

Already have listing URLs? Collect full details for them directly — alone or combined with a location search.

***

### Who it's for

- **Real-estate lead generators & ISAs** — lists of homes + the agent (or team) behind them, with contact details ready for outreach.
- **Mortgage, insurance & home-service providers** — properties in target markets with price, size, and days-on-market signals.
- **Realtors & brokerages** — track competing listings, new inventory, and recently sold comparables.
- **RE investors & acquisitions teams** — for-sale and sold inventory with lot size, taxes, and history for deal screening.
- **Market analysts & researchers** — structured, joinable data across cities for pricing and inventory studies.
- **CRMs, data teams & warehouses** — stable flat JSON that drops straight into Postgres, BigQuery, Airtable, or Sheets.
- **AI & automation builders** — clean rows for LLM prompts, scoring agents, and enrichment pipelines via the Apify API and MCP.

### Use cases

- **Listing-agent lead gen** — run locations nationwide, enable lead details, and get every listing's agent with phone/email when available.
- **Multi-market prospecting** — 50 cities in one run; each row tagged with its location context.
- **New-listing alerts** — daily scheduled runs on "for sale" + webhook → Slack/CRM the moment inventory appears.
- **Sold-comparable analysis** — status "sold" across a zip code, then join against your own valuations.
- **Days-on-market tracking** — `daysOnZillow` + `priceChangePercent` per property over recurring runs.
- **Rental inventory scans** — status "for rent" with `rentZestimate` for portfolio or SaaS data products.
- **Agent & team building** — agent-profile rows become a real-estate contact database with brokerage, license, and service areas.
- **URL enrichment** — bring your own listing URLs, leave with full property records.
- **AI listing summaries** — feed `description`, facts, and taxes to an LLM for instant comparative write-ups.
- **Investor deal flow** — filter price/beds in-run and route matches to your acquisitions CRM by webhook.

### Quick start

1. Open the Actor in Apify Console.
2. Add one or more **locations** (e.g. `Austin, TX`).
3. Choose **listing status** and **max results per location**.
4. Leave **Full property details** and **Enable lead details** on for maximum data per row.
5. Press **Start** and watch rows stream into the dataset.
6. Export as **JSON / CSV / Excel**, pull via the **Apify API**, wire up a **webhook**, or use **MCP**.

#### Example — for-sale homes in two cities

```json
{
  "enableSearch": true,
  "searchLocations": ["Austin, TX", "Denver, CO"],
  "searchStatus": "for_sale",
  "searchMaxResults": 50,
  "enablePropertyDetails": true,
  "enableLeadDetails": true,
  "maxItems": 100
}
```

#### Example — investor screen (price + beds filters)

```json
{
  "searchLocations": ["Phoenix, AZ"],
  "searchStatus": "for_sale",
  "searchMaxResults": 200,
  "searchMinPrice": 150000,
  "searchMaxPrice": 400000,
  "searchMinBeds": 3,
  "maxItems": 200
}
```

#### Example — enrich your own listing URLs

```json
{
  "enableSearch": false,
  "propertyUrls": [
    "https://www.zillow.com/homedetails/1200-Main-St-Austin-TX-78701/12345678_zpid/"
  ],
  "enablePropertyDetails": true,
  "enableLeadDetails": true
}
```

#### Example — agent contact list from profile URLs

```json
{
  "enableSearch": false,
  "enableAgentDetails": true,
  "agentUrls": [
    "https://www.zillow.com/profile/Agent-Name/12345678"
  ],
  "maxItems": 500
}
```

#### Example — results to a webhook (Slack-friendly)

```json
{
  "searchLocations": ["Miami, FL"],
  "searchMaxResults": 25,
  "webhookUrl": "https://hooks.slack.com/services/T000/B000/XXXX",
  "webhookFormat": "slack"
}
```

### Input reference

| Field | Type | Default | Description |
|---|---|---|---|
| `enableSearch` | boolean | `true` | Collect properties across the locations below. |
| `searchLocations` | string\[] | `[]` | Cities, states, or ZIPs — one row per location. |
| `searchStatus` | select | `for_sale` | `for_sale`, `for_rent`, `sold`, `pending`, or `all`. |
| `searchMaxResults` | integer | `20` | Max properties per location (1–500). |
| `searchMinPrice` / `searchMaxPrice` | integer | – | Result filters: keep only properties within this price band. |
| `searchMinBeds` / `searchMaxBeds` | integer | – | Result filters: bedroom range. |
| `searchMinBaths` | integer | – | Result filter: minimum bathrooms. |
| `enablePropertyDetails` | boolean | `true` | Enrich each property with the full detail set. Adds a little extra time per business. |
| `enableLeadDetails` | boolean | `true` | Add lead contact details when available. **Never filters** — every property is exported either way. |
| `propertyUrls` | string\[] | `[]` | Collect full details for specific listing URLs. |
| `enableAgentDetails` | boolean | `false` | Collect full agent profiles from `agentUrls`. |
| `agentUrls` | string\[] | `[]` | Agent profile URLs to collect. |
| `maxItems` | integer | `10000` | Global cap on total rows this run (1–50000). Free plan: capped at 2 — see [Free plan limitations](#free-plan-limitations). |
| `webhookUrl` | string | `""` | Optional. Each row is saved to the dataset **and** delivered to this URL in real time. |
| `webhookFormat` | select | `json` | `json` (full record) or `slack` (message payload). |
| `proxyConfiguration` | proxy | US residential | Apify proxy settings (US residential on by default). |

Provide **at least one** location, property URL, or agent URL.

### Output reference

Every exported record is a **flat JSON object** in the run's dataset, tagged by `featureType`:

| `featureType` | Row shape |
|---|---|
| `search` | Property found via location search (optionally enriched with details + lead details). |
| `property_details` | Full property record collected from a listing URL you provided. |
| `agent_details` | Full agent/realtor profile from an agent URL you provided. |

Common fields on every row:

| Field | Type | Description |
|---|---|---|
| `featureType` | string | `search`, `property_details`, or `agent_details`. |
| `source` | string | Which stage produced the row (e.g. `search`, `search+details`). |
| `scrapedAt` | string | ISO 8601 UTC timestamp of collection. |

Property rows carry the full field set documented in [What you get](#what-you-get--80-data-points-per-property) above; agent rows carry the agent-profile field set. Missing values are `null` — field names are stable across runs, so your transforms won't break.

#### Run summary (`OUTPUT` key-value store)

Each run also writes a summary you can read via the Apify API:

```json
{
  "totalPushed": 120,
  "enabledFeatures": ["search", "lead_details"],
  "errors": [],
  "spendingLimitReached": false,
  "paywall": {
    "detected": true,
    "isPaying": true,
    "pricingTier": "SILVER",
    "blocked": false,
    "limited": false,
    "mode": "limit",
    "freeTierMaxItems": null
  },
  "finishedAt": "2026-07-10T12:00:00.000Z"
}
```

| Summary field | Meaning |
|---|---|
| `totalPushed` | Rows exported this run. |
| `enabledFeatures` | Features that ran (e.g. `search`, `property_details`, `agent_details`, `lead_details`). |
| `errors` | Non-fatal failures, expressed as fixed user-facing sentences. |
| `spendingLimitReached` | `true` when your max run charge was reached — the run then finishes gracefully. |
| `paywall` | Free-plan gate transparency: `detected`, `isPaying`, `pricingTier`, `blocked`, `limited`, `mode`, `freeTierMaxItems`. |
| `finishedAt` | When the run wrapped up. |

#### Dataset views

The dataset ships with ready-made views: **Overview**, **Properties**, and **Agents** — switch between them in the Console's Dataset tab.

***

### Webhooks — real-time delivery to your stack

Every row is **always** saved to the run's dataset. Optionally, set **Webhook URL** and each row is *also* delivered to your URL the moment it is collected — perfect for CRMs, Slack, Zapier, Make, n8n, or Google Sheets.

| Setting | Values |
|---|---|
| `webhookUrl` | Your receiving URL (any service that accepts a POST). |
| `webhookFormat` | `json` = the full record; `slack` = Slack message payload. |

**Payload example (`json` format):**

```json
{
  "featureType": "search",
  "address": "1200 Main St, Austin, TX 78701",
  "city": "Austin",
  "state": "TX",
  "price": 725000,
  "bedrooms": 3,
  "bathrooms": 2,
  "squareFeet": 1840,
  "agentName": "Jane Doe",
  "agentPhone": "(512) 555-0142",
  "agentEmail": "jane@example.com",
  "propertyUrl": "https://www.zillow.com/homedetails/...",
  "scrapedAt": "2026-07-10T12:00:00.000Z"
}
```

**Payload example (`slack` format):**

```json
{
  "text": ":house: *1200 Main St, Austin, TX 78701*\n*Price:* $725,000\n*3 bd / 2 ba*\n*Agent:* Jane Doe • (512) 555-0142\n<View listing|...>"
}
```

Failed deliveries are logged as a single warning (`Webhook delivery failed`) and **never** interrupt the run or dataset writes.

**Apify's own webhooks** (run succeeded / failed / aborted) are configured separately under your run's *Storage* → *Webhooks* in the Console and work with any Actor.

***

### Integrations — API, MCP, and automations

#### Apify API

Pull results programmatically as JSON, CSV, or Excel:

- `GET https://api.apify.com/v2/datasets/{DATASET_ID}/items` — your rows.
- Full reference: [Apify API v2](https://docs.apify.com/api/v2)

Start and monitor runs with `POST /v2/acts/{actorId}/runs` — schedule them with [Schedules](https://docs.apify.com/platform/schedules) for daily inventory or lead refreshes.

#### MCP usage (AI assistants)

Use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) so AI assistants (Claude, ChatGPT, Cursor, and others) can **run this Actor and read its results directly in chat**:

1. Connect the Apify MCP server to your assistant ([setup guide](https://docs.apify.com/platform/integrations/mcp)).
2. Ask in natural language — the assistant calls this Actor with the right input.
3. Results come back as dataset items the assistant can summarize, tabulate, or chain onward.

Example prompts:

```
"Collect 30 for-sale homes in Austin, TX under $600k with at least 3 bedrooms and summarize each in two sentences."
"Run the Zillow actor for Miami, FL and turn the top 20 results into a CSV table with address, price, and agent phone."
"Find recently sold homes in Denver and group them by price band."
```

Typical MCP flow:

```
User: "Collect 10 condos in San Diego under $500k and draft outreach to their listing agents"
→ MCP runs Actor with searchLocations=["San Diego, CA"], searchMaxResults=10, maxItems=10
→ MCP reads dataset items (address, price, agentName, agentEmail)
→ Assistant drafts the outreach
```

#### LLM & RAG pipelines

Output is stable, flat JSON — ideal for ChatGPT, Claude, Gemini, LangChain, and LlamaIndex:

```json
{
  "featureType": "search",
  "address": "1200 Main St, Austin, TX 78701",
  "price": 725000,
  "bedrooms": 3,
  "bathrooms": 2,
  "daysOnZillow": 12,
  "agentName": "Jane Doe",
  "agentEmail": "jane@example.com",
  "scrapedAt": "2026-07-10T12:00:00.000Z"
}
```

Workflow: run the Actor → fetch dataset items via the API → pass records to your LLM or vector store.

#### Native integrations

Push rows straight from the dataset to **Google Sheets, Airtable, Dropbox, Google Drive, Zapier, Make, and more** via [Apify Integrations](https://docs.apify.com/platform/integrations) — no code required.

***

### Pricing

- **Pay per exported result** (pay-per-event). You are charged for rows actually delivered to your dataset — not for time, and not for work you don't receive.
- **Spending limit respected:** if you set a max charge for a run in Apify, the Actor stops gracefully the moment that limit is reached, with a clear status message — never an overrun. See [Apify's pay-per-event docs](https://docs.apify.com/actors/publishing/monetize/pay-per-event#respect-user-spending-limits).
- **Cost levers:** lower `maxItems`, lower `searchMaxResults`, and turn off **Full property details** / **Enable lead details** for lighter runs.

#### Free plan limitations

Apify free-plan accounts are limited to a **2-result sample per run**. The run log shows an explicit notice to **upgrade to a paid Apify plan for full, unlimited data**, and the run's `paywall` summary object records the decision (`detected`, `isPaying`, `pricingTier`, `blocked`, `limited`). This is a transparent platform plan restriction — runs finish cleanly; nothing errors. **Paid plans (Bronze and above) always get the full, normal output with no cap.**

***

### Performance & scale

- **Streaming:** rows are written to the dataset as they are collected — memory stays light and a long run never loses completed work.
- **512 MB** default memory (configurable up to 2 GB).
- **10,000-second** run timeout — supports very large multi-location runs.
- **Up to 50,000 rows** per run (`maxItems`).
- **US residential connectivity** enabled by default for consistent results.

***

### FAQ

**Do I need a Zillow API key or account?**\
No. Just enter locations and press Start.

**What does "real-time" mean here?**\
Data is collected when your run executes — not served from a stale cache. Schedule runs to keep it fresh.

**I'm on the Apify free plan — why only 2 results?**\
That's the platform free-plan restriction for this Actor: 2 results per run plus an upgrade notice in the log. Upgrade to any paid Apify plan for full, unlimited output. See [Free plan limitations](#free-plan-limitations).

**Will rows without contact details be dropped?**\
Never. **Enable lead details** adds contact information when it's available — it never filters. Every collected property is exported, so run time and cost stay predictable.

**Why does a run take a little longer with lead details on?**\
Lead details add a little extra time per business. Turn the toggle off if you only need property facts.

**Some of my property URLs produced no row — why?**\
Rows are only exported for listings that were successfully collected. Unavailable or invalid listings are skipped and noted in the log with a fixed, generic message.

**Can I filter by price or beds?**\
Yes — set `searchMinPrice`, `searchMaxPrice`, `searchMinBeds`, `searchMaxBeds`, or `searchMinBaths`. Rows missing that data point don't match a set filter.

**How do webhooks work?**\
Set `webhookUrl` (and `webhookFormat`) and each row is delivered to your URL as it is collected, in addition to being saved to the dataset. Failures log one warning and never stop the run.

**Can AI assistants use this Actor?**\
Yes — connect the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) and run it with natural language. See [MCP usage](#mcp-usage-ai-assistants).

**How do I control cost?**\
Use `maxItems` as the hard cap, keep per-location results realistic, and set a run spending limit in Apify — the Actor honors it and stops gracefully.

**What does `spendingLimitReached: true` mean?**\
Your configured max charge for that run was reached. The run wrapped up cleanly with everything collected so far saved.

**What do the `paywall` fields mean?**\
They make the free-plan gate visible in the run output: whether it was detected, whether the account is paying, the pricing tier, and whether results were capped or blocked.

**Is the data public?**\
The Actor collects publicly displayed listing information only.

**Which countries/locations work?**\
Any location Zillow lists — cities, regional areas, and ZIP codes across the US.

**How often can I run it?**\
As often as you like, bounded by your Apify plan and spending limits. Scheduled runs are supported.

**What does "Webhook delivery failed" in the log mean?**\
Your receiving URL rejected or timed out the delivery. Dataset writes are unaffected — fix the receiver or re-deliver from your own queue.

**How do I export data?**\
Console export (JSON/CSV/Excel), the [Apify API](https://docs.apify.com/api/v2), native integrations, or your webhook.

***

### Support

Open an issue on this Actor's GitHub repository or contact the developer through the Apify Store page.

### License

See repository for license details.

# Actor input Schema

## `enableSearch` (type: `boolean`):

Find properties across one or more locations (city, state, or ZIP). Enabled by default.

## `searchLocations` (type: `array`):

Locations to collect properties from, e.g. "Austin, TX", "Beverly Hills, CA", "90210". One row per location.

## `searchStatus` (type: `string`):

Which listings to collect for each location.

## `searchMaxResults` (type: `integer`):

How many properties to collect for each location. Potential total = this value × number of locations, bounded by Max total items below.

## `searchMinPrice` (type: `integer`):

Only keep properties priced at or above this value. Leave empty for no minimum.

## `searchMaxPrice` (type: `integer`):

Only keep properties priced at or below this value. Leave empty for no maximum.

## `searchMinBeds` (type: `integer`):

Only keep properties with at least this many bedrooms. Leave empty for no minimum.

## `searchMaxBeds` (type: `integer`):

Only keep properties with at most this many bedrooms. Leave empty for no maximum.

## `searchMinBaths` (type: `integer`):

Only keep properties with at least this many bathrooms. Leave empty for no minimum.

## `enablePropertyDetails` (type: `boolean`):

Enrich every property with full details: description, taxes, HOA, schools, days on market, features, history, and listing agent. Adds a little extra time per business. On by default.

## `enableLeadDetails` (type: `boolean`):

Add lead contact details to each property — agent name, phone, email, website, and social profiles when available. Every property is still exported even when no lead details are found (nothing is dropped). Adds a little extra time per business. On by default.

## `propertyUrls` (type: `array`):

Collect full details for specific property listing URLs. Can be combined with a location search, used on its own, or left empty.

## `enableAgentDetails` (type: `boolean`):

Collect full agent/realtor profiles from the profile URLs below: contact info, brokerage, license, service areas, social profiles, and recent activity.

## `agentUrls` (type: `array`):

Agent/realtor profile URLs to collect (only used when Agent profiles is enabled).

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

Global cap on total rows exported in this run, across all features. NOTE: On the Apify free plan this is capped to a small sample (2 results) per run — upgrade to a paid Apify plan to get full, unlimited data. See the README for current free-tier limits.

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

Optional. Every record is always saved to the run's dataset — this webhook is an ADDITIONAL real-time push. When set, each new record is also delivered to this URL (CRM, Slack incoming webhook, Zapier, Make, Google Sheets).

## `webhookFormat` (type: `string`):

json = full record object; slack = Slack-friendly message payload.

## `proxyConfiguration` (type: `object`):

Apify residential proxy (US) is enabled by default for reliable collection. Change here only if you need a different country or custom proxy URLs.

## Actor input object example

```json
{
  "enableSearch": true,
  "searchLocations": [
    "Austin, TX"
  ],
  "searchStatus": "for_sale",
  "searchMaxResults": 20,
  "enablePropertyDetails": true,
  "enableLeadDetails": true,
  "propertyUrls": [],
  "enableAgentDetails": false,
  "agentUrls": [],
  "maxItems": 10000,
  "webhookUrl": "",
  "webhookFormat": "json",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `allResults` (type: `string`):

Complete dataset with every field from all enabled features in this run.

## `properties` (type: `string`):

Property rows from location search and property URLs.

## `agents` (type: `string`):

Agent/realtor profile rows.

## `runSummary` (type: `string`):

Per-run metadata: enabled features, exported record count, non-fatal errors, spending-limit status, and the paywall object (detected, isPaying, pricingTier, blocked, limited).

# 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 = {
    "enableSearch": true,
    "searchLocations": [
        "Austin, TX"
    ],
    "searchStatus": "for_sale",
    "searchMaxResults": 20,
    "enablePropertyDetails": true,
    "enableLeadDetails": true,
    "enableAgentDetails": false,
    "maxItems": 10000,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("b2b_leads/zillow-real-time-data-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 = {
    "enableSearch": True,
    "searchLocations": ["Austin, TX"],
    "searchStatus": "for_sale",
    "searchMaxResults": 20,
    "enablePropertyDetails": True,
    "enableLeadDetails": True,
    "enableAgentDetails": False,
    "maxItems": 10000,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("b2b_leads/zillow-real-time-data-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 '{
  "enableSearch": true,
  "searchLocations": [
    "Austin, TX"
  ],
  "searchStatus": "for_sale",
  "searchMaxResults": 20,
  "enablePropertyDetails": true,
  "enableLeadDetails": true,
  "enableAgentDetails": false,
  "maxItems": 10000,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call b2b_leads/zillow-real-time-data-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,b2b_leads/zillow-real-time-data-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/HVXlzyVaadgyqutja/builds/tLINoiOlUcuEDbMA3/openapi.json