# Zillow Scraper — (w/ Property Search, Zip codes & Agent Leads) (`khadinakbar/zillow-all-in-one-scraper`) Actor

Scrape Zillow listings with 40+ fields: address, price, Zestimate, price history, agent contact info, school ratings, walk score & more. Search by city, ZIP code, direct URL, or ZPID. Outputs CRM-ready JSON. Perfect for real estate investors, lead gen, and market research.

- **URL**: https://apify.com/khadinakbar/zillow-all-in-one-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Lead generation, Real estate, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 property scrapeds

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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 All-in-One Scraper — Properties, Prices & Agent Leads

### What does Zillow All-in-One Scraper do?

This actor extracts **50+ fields per listing** from Zillow in a single run — combining search results AND full listing details without needing two separate actors. Search by keyword, feed direct URLs, look up ZPIDs, or sweep entire ZIP codes. Get price history, Zestimate, agent contact info, walkability scores, nearby schools, tax records, and more — all in clean, CRM-ready JSON.

Export scraped data, run the scraper via API, schedule and monitor runs, or integrate with other tools.

### Why use Zillow All-in-One Scraper?

- **One actor, full data.** Other solutions split search and detail scraping into separate actors, requiring you to stitch results. This actor does both in one pass.
- **50+ fields per listing.** Price history, tax history, agent phone/email, Zestimate, rent estimate, walk score, transit score, nearby schools — fields that other scrapers don't include.
- **4 input modes.** Search by keyword/location, direct Zillow URLs, ZPID arrays, or ZIP code lists. Use whichever fits your workflow.
- **Cheaper than the alternative.** Running Zillow Search Scraper + Zillow Detail Scraper separately costs ~$0.005/listing. This actor costs $0.004/listing with more data.
- **Built for B2B.** Agent lead generation, real estate investment analysis, CRM enrichment, market comps — this actor is structured for business workflows.

### What data does Zillow All-in-One Scraper extract?

| Field | Type | Description |
|---|---|---|
| zpid | string | Zillow property ID (unique key) |
| url | string | Full Zillow listing URL |
| address | object | Street, city, state, ZIP, neighborhood |
| latitude / longitude | number | GPS coordinates |
| price | number | Listing price in USD |
| price_per_sqft | number | Price divided by living area |
| zestimate | number | Zillow's automated valuation |
| rent_zestimate | number | Estimated monthly rental value |
| listing_status | string | FOR_SALE, FOR_RENT, RECENTLY_SOLD |
| property_type | string | SINGLE_FAMILY, CONDO, TOWNHOUSE, etc. |
| days_on_market | number | Days listed on Zillow |
| bedrooms / bathrooms | number | Room counts |
| living_area_sqft | number | Finished living area |
| lot_size_sqft | number | Total lot size |
| year_built | number | Construction year |
| garage_spaces | number | Garage capacity |
| has_pool | boolean | Pool present |
| description | string | Full listing description |
| features | string[] | Appliances, interior/exterior features |
| photos | string[] | High-resolution photo URLs |
| virtual_tour_url | string | 3D tour link if available |
| open_house_dates | string[] | Upcoming open house times |
| hoa_fee | number | Monthly HOA fee |
| annual_tax | number | Estimated annual property tax |
| price_history | array | Date, price, event for all price changes |
| tax_history | array | Year and tax amount per year |
| agent_name | string | Listing agent full name |
| agent_phone | string | Agent phone number |
| agent_email | string | Agent email address |
| agent_license | string | Agent license number |
| broker_name | string | Listing brokerage name |
| mls_id | string | MLS identifier |
| walk_score | number | Walkability score (0–100) |
| transit_score | number | Transit access score (0–100) |
| bike_score | number | Bikeability score (0–100) |
| nearby_schools | array | School name, type, rating, distance |
| scraped_at | string | ISO 8601 timestamp |
| source_url | string | Exact URL scraped |

### How to use Zillow All-in-One Scraper

#### Mode 1: Search by keyword (most common)

Enter a location, neighborhood, or keyword search in the **Search Query** field:

````

Austin, TX
3BR condos in downtown Denver
Homes near UCLA Los Angeles

```

Pair with listing type (For Sale / For Rent / Recently Sold) and optional filters like price range, minimum beds/baths.

#### Mode 2: Direct Zillow URLs

Paste Zillow listing URLs directly into **Direct Zillow URLs**:

```

https://www.zillow.com/homedetails/123-Main-St-Austin-TX-78701/87802938\_zpid/
https://www.zillow.com/homedetails/456-Oak-Ave-Denver-CO-80203/12345678\_zpid/

```

Best for when you already have a list of properties and want full data enrichment.

#### Mode 3: ZPID lookup

Provide Zillow property IDs (ZPIDs) in the **Zillow Property IDs** field:

```

87802938
12345678
99887766

```

Great for CRM enrichment — when you already have ZPIDs in your database.

#### Mode 4: ZIP code sweep

Enter ZIP codes in the **ZIP Codes** field:

```

78701
78702
78703

````

The actor sweeps every active listing in each ZIP. Ideal for bulk market analysis.

#### API usage example

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('USERNAME/zillow-all-in-one-scraper').call({
    searchQuery: 'Austin, TX',
    listingType: 'FOR_SALE',
    minBeds: 3,
    maxPrice: 600000,
    maxResults: 100,
    proxyConfiguration: { useApifyProxy: true, apifyProxyGroups: ['RESIDENTIAL'] },
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Scraped ${items.length} properties`);
console.log(items[0]);
// { zpid: '87802938', price: 450000, agent_name: 'Jane Smith', agent_phone: '(512) 555-0123', ... }
````

#### Example output

```json
{
  "zpid": "87802938",
  "url": "https://www.zillow.com/homedetails/123-Main-St-Austin-TX-78701/87802938_zpid/",
  "address": {
    "street": "123 Main St",
    "city": "Austin",
    "state": "TX",
    "zip": "78701",
    "neighborhood": "Downtown Austin",
    "subdivision": null
  },
  "latitude": 30.2672,
  "longitude": -97.7431,
  "price": 450000,
  "price_per_sqft": 281,
  "zestimate": 448000,
  "rent_zestimate": 2350,
  "listing_status": "FOR_SALE",
  "property_type": "SINGLE_FAMILY",
  "days_on_market": 12,
  "bedrooms": 3,
  "bathrooms": 2.5,
  "living_area_sqft": 1600,
  "lot_size_sqft": 6500,
  "year_built": 2005,
  "garage_spaces": 2,
  "has_pool": false,
  "hoa_fee": null,
  "annual_tax": 8200,
  "zestimate": 448000,
  "price_history": [
    { "date": "2026-03-28", "price": 465000, "event": "Listed" },
    { "date": "2026-04-01", "price": 450000, "event": "Price Cut" }
  ],
  "agent_name": "Jane Smith",
  "agent_phone": "(512) 555-0123",
  "agent_email": "jane.smith@realty.com",
  "broker_name": "Austin Premier Realty",
  "mls_id": "1234567",
  "walk_score": 72,
  "transit_score": 45,
  "bike_score": 58,
  "nearby_schools": [
    { "name": "Austin Elementary", "type": "Elementary", "rating": 8, "distance": 0.4 }
  ],
  "scraped_at": "2026-04-09T14:32:00.000Z",
  "source_url": "https://www.zillow.com/homedetails/..."
}
```

### Pricing

This actor uses **pay-per-event pricing**: **$0.004 per property listing** extracted.

| Results | Cost |
|---|---|
| 10 properties | $0.04 |
| 100 properties | $0.40 |
| 500 properties | $2.00 |
| 1,000 properties | $4.00 |
| 5,000 properties | $20.00 |

**Why this is a good deal:** Running Zillow's own search scraper ($0.002) + detail scraper ($0.003) separately costs $0.005/property — plus the effort of stitching two datasets together. This actor delivers more fields for $0.004 in a single run.

Apify provides $5 in free credits every month on the Free plan — enough for ~1,250 properties.

### Proxy requirements

Zillow actively blocks datacenter IP addresses. **Residential proxies are required** and are pre-configured by default using Apify's Residential proxy group. Do not change this to datacenter proxies — you will receive 403 errors.

Residential proxy usage is included in your Apify proxy billing, separate from actor event charges.

### Use cases

**Real estate investment:** Sweep entire zip codes for undervalued properties. Compare price vs. Zestimate to find motivated sellers. Analyze price history for trend signals.

**Agent lead generation:** Extract agent name, phone, and email from competitor listings. Build targeted outreach lists for real estate marketing campaigns.

**Market research:** Track median prices, days on market, and listing volumes across neighborhoods over time. Schedule weekly runs for ongoing market pulse data.

**CRM enrichment:** Feed ZPIDs from your database into the actor to refresh stale property records with current prices, status, and agent contact info.

**Skip tracing complement:** Combine with property owner data workflows — use price history and tax history fields to identify distressed properties.

### Works great with

- **[Skip Trace Property Owner Scraper](https://apify.com/USERNAME/skip-trace-property-owner)** — find property owners from the listing data extracted here
- **[Bulk Website Contact Extractor](https://apify.com/USERNAME/bulk-website-contact-extractor)** — enrich agent broker websites with additional contact details

### FAQ

**Q: Does this scraper require a Zillow account?**
A: No. All data is extracted from Zillow's publicly accessible listing pages. No login required.

**Q: How many results can I get per search?**
A: Zillow limits search results to approximately 500 per geographic tile. For larger areas, use ZIP code mode to sweep multiple smaller areas, or use the maxResults limit to control volume.

**Q: Why do some listings have null fields?**
A: Not every listing has all fields. New listings may lack price history. Land listings won't have bedroom/bathroom data. Rental listings may not show agent email. All fields are always present in the output (never omitted), but some will be `null`.

**Q: Can I scrape rental listings?**
A: Yes. Set `listingType` to `FOR_RENT` in your input configuration.

**Q: How often is Zillow's data updated?**
A: Listing data on Zillow is updated frequently (multiple times daily for active listings). Schedule regular actor runs to keep your data fresh.

**Q: What happens if I hit Zillow's bot detection?**
A: The actor uses residential proxies and session rotation to minimize detection. If a request fails, it retries automatically up to 3 times with a fresh session and proxy. Success rates above 93% are typical.

### Legal disclaimer

This actor is intended for lawful data collection from publicly available sources. Users are responsible for compliance with applicable laws, Zillow's Terms of Service, and data protection regulations (GDPR, CCPA, etc.). Zillow property data is publicly available on the internet. Always ensure your use case complies with local laws governing data collection and use.

# Actor input Schema

## `searchQuery` (type: `string`):

Use this field when the user provides a location, neighborhood, city, or keyword like '3BR homes in Austin TX' or 'condos near downtown Denver'. Do NOT use this when the user has specific Zillow listing URLs — use startUrls instead. Do NOT use when the user has Zillow property IDs (ZPIDs) — use zpids instead.

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

Use this field when the user provides specific Zillow property listing URLs (e.g., https://www.zillow.com/homedetails/...). Each URL is fully scraped for all 50+ fields. Do NOT use this for search queries — use searchQuery instead.

## `zpids` (type: `array`):

Use this field when the user provides Zillow property IDs (numeric, e.g. \['12345678', '87654321']). The actor builds the detail URL from each ZPID automatically. Great for CRM enrichment workflows.

## `zipCodes` (type: `array`):

Use this field when the user wants all listings in specific ZIP codes (e.g., \['78701', '78702', '78703']). Bulk market analysis by geography. Each ZIP code is swept for all active listings.

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

Filter listings by sale status. FOR\_SALE = active listings on market. FOR\_RENT = rental listings. RECENTLY\_SOLD = homes sold in the last 90 days (great for comps and market analysis).

## `propertyTypes` (type: `array`):

Filter by property type. Leave empty for all types. Enter one or more values per line: SINGLE\_FAMILY, CONDO, TOWNHOUSE, MULTI\_FAMILY, LAND, APARTMENT, MANUFACTURED.

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

Minimum listing price in USD. Leave empty for no minimum.

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

Maximum listing price in USD. Leave empty for no maximum.

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

Minimum number of bedrooms. Leave empty for no minimum.

## `minBaths` (type: `number`):

Minimum number of bathrooms. Leave empty for no minimum.

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

Maximum number of property listings to scrape. Each listing = 1 charge event at $0.004. Set to 10 for a quick test. Set to 500+ for bulk market analysis.

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

Zillow requires residential proxies to avoid blocks. Apify Residential proxy is pre-configured and recommended. Do not switch to datacenter — Zillow blocks datacenter IPs aggressively.

## Actor input object example

```json
{
  "searchQuery": "Austin, TX",
  "startUrls": [],
  "zpids": [],
  "zipCodes": [],
  "listingType": "FOR_SALE",
  "propertyTypes": [],
  "maxResults": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Link to the dataset containing all extracted Zillow property listings.

# 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 = {
    "searchQuery": "Austin, TX",
    "maxResults": 50,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/zillow-all-in-one-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 = {
    "searchQuery": "Austin, TX",
    "maxResults": 50,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/zillow-all-in-one-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 '{
  "searchQuery": "Austin, TX",
  "maxResults": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call khadinakbar/zillow-all-in-one-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Zillow Scraper — (w/ Property Search, Zip codes & Agent Leads)",
        "description": "Scrape Zillow listings with 40+ fields: address, price, Zestimate, price history, agent contact info, school ratings, walk score & more. Search by city, ZIP code, direct URL, or ZPID. Outputs CRM-ready JSON. Perfect for real estate investors, lead gen, and market research.",
        "version": "1.4",
        "x-build-id": "Rdzj1iTTmxV5Xu2pZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~zillow-all-in-one-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-zillow-all-in-one-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/khadinakbar~zillow-all-in-one-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-zillow-all-in-one-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/khadinakbar~zillow-all-in-one-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-zillow-all-in-one-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Use this field when the user provides a location, neighborhood, city, or keyword like '3BR homes in Austin TX' or 'condos near downtown Denver'. Do NOT use this when the user has specific Zillow listing URLs — use startUrls instead. Do NOT use when the user has Zillow property IDs (ZPIDs) — use zpids instead."
                    },
                    "startUrls": {
                        "title": "Direct Zillow URLs",
                        "type": "array",
                        "description": "Use this field when the user provides specific Zillow property listing URLs (e.g., https://www.zillow.com/homedetails/...). Each URL is fully scraped for all 50+ fields. Do NOT use this for search queries — use searchQuery instead.",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "zpids": {
                        "title": "Zillow Property IDs (ZPIDs)",
                        "type": "array",
                        "description": "Use this field when the user provides Zillow property IDs (numeric, e.g. ['12345678', '87654321']). The actor builds the detail URL from each ZPID automatically. Great for CRM enrichment workflows.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "zipCodes": {
                        "title": "ZIP Codes",
                        "type": "array",
                        "description": "Use this field when the user wants all listings in specific ZIP codes (e.g., ['78701', '78702', '78703']). Bulk market analysis by geography. Each ZIP code is swept for all active listings.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "listingType": {
                        "title": "Listing Type",
                        "enum": [
                            "FOR_SALE",
                            "FOR_RENT",
                            "RECENTLY_SOLD"
                        ],
                        "type": "string",
                        "description": "Filter listings by sale status. FOR_SALE = active listings on market. FOR_RENT = rental listings. RECENTLY_SOLD = homes sold in the last 90 days (great for comps and market analysis).",
                        "default": "FOR_SALE"
                    },
                    "propertyTypes": {
                        "title": "Property Types (optional filter)",
                        "type": "array",
                        "description": "Filter by property type. Leave empty for all types. Enter one or more values per line: SINGLE_FAMILY, CONDO, TOWNHOUSE, MULTI_FAMILY, LAND, APARTMENT, MANUFACTURED.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "minPrice": {
                        "title": "Min Price ($)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum listing price in USD. Leave empty for no minimum."
                    },
                    "maxPrice": {
                        "title": "Max Price ($)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum listing price in USD. Leave empty for no maximum."
                    },
                    "minBeds": {
                        "title": "Min Bedrooms",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Minimum number of bedrooms. Leave empty for no minimum."
                    },
                    "minBaths": {
                        "title": "Min Bathrooms",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "number",
                        "description": "Minimum number of bathrooms. Leave empty for no minimum."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of property listings to scrape. Each listing = 1 charge event at $0.004. Set to 10 for a quick test. Set to 500+ for bulk market analysis.",
                        "default": 50
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Zillow requires residential proxies to avoid blocks. Apify Residential proxy is pre-configured and recommended. Do not switch to datacenter — Zillow blocks datacenter IPs aggressively.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
