# Zillow Scraper (`silentflow/zillow-scraper`) Actor

Scrape Zillow listings by city, ZIP, or neighborhood. Pull homes for sale, for rent, and recently sold with prices, beds, baths, photos, and Zestimates, plus full detail: price and tax history, schools, lot facts, and agent contacts. No 1,000-result cap. Export to CSV, JSON, or Excel for comps.

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

## Pricing

from $0.60 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 Scraper

**Turn any U.S. city, ZIP, or neighborhood into a clean feed of Zillow listings. For sale, for rent, or recently sold, with prices, beds, baths, photos, valuations, and full property detail in one structured record per home.**

Type a location. Get back every listing that matches, with the fields you actually use for comps, lead lists, and market analysis. No copy-pasting from Zillow tabs, no building search URLs by hand, no hitting the 1,000-result wall.

### How it works

![How it works](https://api.apify.com/v2/key-value-stores/uWL5gvLMJkujM02WR/records/how-it-works-v1.png)

1. **You enter a location.** A city like `Austin, TX`, a ZIP like `90210`, a neighborhood, county, or state. Add price, bed, bath, or home-type filters if you want.
2. **The scraper pulls every matching listing.** Buy, rent, or sold, across the whole area, not just the first page Zillow shows you.
3. **You get one structured record per home**, ready to export to CSV or Excel, drop into a sheet, or feed into a model or dashboard.

Turn on **Fetch Details** and each home is enriched with its full property profile: price history, tax history, assigned schools, lot and construction facts, HOA, agent name and phone, and more.

### ✨ Why teams choose this over other Zillow scrapers

Building search URLs by hand just to scrape a city? Hitting the 1,000-result cap on a big metro? Stuck with raw listing dumps that are missing the fields you actually need?

- 🏙️ **Just type a location.** A city, ZIP, neighborhood, or address. No building a Zillow URL, no copying map coordinates, no learning a query format. Most scrapers make you do that work yourself.
- ♾️ **No 1,000-result limit.** Pull every for-sale, rental, or sold home in an entire metro, not the capped page Zillow shows in the browser. Big markets come back complete.
- 🏠 **Buy, rent, and sold in one place.** One Actor handles all three. Switch with a single setting instead of wiring up three different tools.
- 📜 **The full property story, not just the card.** Turn on detail enrichment and get price history, tax history, assigned schools, lot and construction facts, HOA, and Zestimate. The data behind the listing, not just the headline.
- 📇 **Agent contact details.** Pull the listing agent's name, phone, and brokerage for outreach and lead lists, captured straight from the listing.
- 📸 **Whole photo galleries, ready to use.** Full-resolution image URLs for every photo, not a single thumbnail and not raw keys you have to assemble.
- 📉 **Spot price drops and deals.** Every listing carries its price change and the date it changed, so you can surface reductions the moment they happen.
- 💰 **Pay per result, not per minute.** Proxies included, no compute fees. You pay for homes delivered, and nothing else.
- 🧹 **One clean record per home.** Normalized JSON with a flat, predictable shape. It drops straight into a spreadsheet, a CRM, or an AI workflow.

### 🎯 What you can do with Zillow data

| Team | What they build |
|------|-----------------|
| Real estate investors | Pull every sold home in a ZIP with price and tax history to run comps and spot undervalued deals |
| Agents and brokerages | Build for-sale and for-rent lead lists by city with the listing agent's name and phone attached |
| Proptech and data products | Power a property search app or AVM with normalized buy, rent, and sold listings at scale |
| Market analysts | Track price drops, days on market, and inventory across neighborhoods over time |
| Mortgage and lending | Enrich applications with tax history, valuations, and assigned-school data for a property |
| Rental operators | Aggregate every rental in a metro with rent, beds, baths, and per-unit pricing for buildings |
| Researchers | Compare home values, year built, and lot size across cities and ZIP codes |

### 📥 Input parameters

You only need a location and how many homes you want. Everything else is optional.

#### Core

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `location` | string | Yes* | A city, ZIP, neighborhood, county, state, or address. Example: `Austin, TX`. |
| `locations` | array of strings | No | Search several locations in one run. Overrides `location` when set. |
| `operation` | string | No | `buy`, `rent`, or `sold`. Default `buy`. |
| `maxItems` | integer | Yes | Maximum number of listings to return. Default `100`. |
| `fetchDetails` | boolean | No | Enrich each listing with full detail-page data (price/tax history, schools, lot facts, agent). Default `false`. |

\* Provide either `location` or `locations`.

#### Filters

| Field | Type | Description |
|-------|------|-------------|
| `minPrice` / `maxPrice` | integer | Price range. Per month for rentals. `0` for any. |
| `minBeds` / `maxBeds` | integer | Bedroom range. `0` for any. |
| `minBaths` | number | Minimum bathrooms. |
| `homeTypes` | array | Restrict to `houses`, `townhomes`, `multifamily`, `condos`, `land`, `apartments`, `manufactured`. Empty for all. |
| `sortBy` | string | `newest`, `relevance`, `lowPrice`, `highPrice`, `bedrooms`, `bathrooms`, `sqft`, `lotSize`, `yearBuilt`. |
| `locationType` | string | Force a match type (`city`, `zipcode`, `neighborhood`, `county`, `state`) when a name is ambiguous. Auto-detects by default. |

```json
{
  "location": "Austin, TX",
  "operation": "buy",
  "maxItems": 500,
  "minPrice": 300000,
  "maxPrice": 600000,
  "minBeds": 3,
  "homeTypes": ["houses"],
  "sortBy": "newest"
}
````

### 📊 Output data

One record per home. The base record covers everything on the listing card and more.

```json
{
  "zpid": "29489604",
  "url": "https://www.zillow.com/homedetails/5800-Breezewood-Dr-Austin-TX-78745/29489604_zpid/",
  "operation": "buy",
  "statusText": "Active",
  "homeStatus": "FOR_SALE",
  "homeType": "SINGLE_FAMILY",
  "price": 350000,
  "currency": "USD",
  "pricePerSqft": 299.15,
  "beds": 3,
  "baths": 2,
  "livingArea": 1170,
  "lotAreaValue": 6298.776,
  "lotAreaUnit": "sqft",
  "address": { "streetAddress": "5800 Breezewood Dr", "city": "Austin", "state": "TX", "zipcode": "78745" },
  "latitude": 30.204609,
  "longitude": -97.77888,
  "daysOnZillow": 1,
  "zestimate": 352800,
  "rentZestimate": 2450,
  "taxAssessedValue": 328033,
  "priceChange": -17000,
  "datePriceChanged": "2026-06-18",
  "listingTypes": ["FSBA"],
  "brokerName": "Jorgenson Real Estate",
  "photos": ["https://photos.zillowstatic.com/fp/00b223faef21b41ee54f5db0bcf4a1ce-p_e.jpg"]
}
```

With `fetchDetails: true`, each record gains a `details` object with the full property profile:

```json
{
  "zpid": "29489604",
  "price": 350000,
  "details": {
    "description": "Clean, move-in-ready home in South Austin...",
    "yearBuilt": 1971,
    "lotSize": "6,298 sqft",
    "parcelNumber": "04160911220000",
    "taxAnnualAmount": 5793,
    "monthlyHoaFee": 0,
    "stories": 1,
    "heating": ["Central", "Electric"],
    "cooling": ["Central Air", "Electric"],
    "appliances": ["Dishwasher", "Gas Range", "Microwave", "Oven"],
    "agentName": "Mike Kelly",
    "agentPhone": "(512) 439-3698",
    "brokerName": "Jorgenson Real Estate",
    "mlsId": "4443738",
    "priceHistory": [
      { "date": "2026-06-25", "event": "Listed for sale", "price": 350000, "pricePerSqft": 299 }
    ],
    "taxHistory": [
      { "year": "2025", "taxPaid": 4744.89, "value": 328033, "valueIncreaseRate": -0.14 }
    ],
    "schools": [
      { "name": "Pleasant Hill Elementary School", "rating": 3, "grades": "PK-5", "distance": 0.6 }
    ]
  }
}
```

### 🗂️ Data fields

**Listing**

| Category | Fields |
|----------|--------|
| Identity | `zpid`, `url`, `operation`, `statusType`, `statusText`, `homeStatus` |
| Price | `price`, `priceText`, `currency`, `pricePerSqft`, `priceChange`, `datePriceChanged` |
| Size | `beds`, `baths`, `livingArea`, `lotAreaValue`, `lotAreaUnit`, `homeType` |
| Location | `address` (street, city, state, ZIP), `latitude`, `longitude` |
| Market | `daysOnZillow`, `zestimate`, `rentZestimate`, `taxAssessedValue`, `dateSold` |
| Flags | `listingTypes`, `isFeatured`, `isZillowOwned`, `isNonOwnerOccupied`, `isPremierBuilder`, `hasVideo`, `has3DModel` |
| Media | `imgSrc`, `photos` |
| Broker | `brokerName` |
| Rentals | `unit`, `isBuilding`, `buildingName`, `minBaseRent`, `maxBaseRent`, `unitCount`, `units` |

**Details** (with `fetchDetails: true`)

| Category | Fields |
|----------|--------|
| Description | `description`, `yearBuilt`, `lotSize`, `stories`, `parcelNumber` |
| Facts | `heating`, `cooling`, `appliances`, `flooring`, `hasGarage`, `parkingCapacity`, `pricePerSqft` |
| Money | `zestimate`, `rentZestimate`, `monthlyHoaFee`, `propertyTaxRate`, `taxAnnualAmount`, `lastSoldPrice` |
| History | `priceHistory`, `taxHistory` |
| Schools | `schools` (name, rating, grades, distance, link) |
| Agent | `agentName`, `agentPhone`, `agentEmail`, `brokerName`, `mlsId`, `mlsName` |

### 🚀 Examples

**Get the newest homes for sale in a city**

```json
{ "location": "Austin, TX", "operation": "buy", "maxItems": 200 }
```

**Pull every recently sold home in a ZIP for comps**

```json
{ "location": "78745", "operation": "sold", "maxItems": 1000, "fetchDetails": true }
```

**Build a rental lead list under a budget**

```json
{ "location": "Denver, CO", "operation": "rent", "maxPrice": 2500, "minBeds": 2, "maxItems": 500 }
```

**Find 4-bed houses in a price band with full detail**

```json
{ "location": "Phoenix, AZ", "operation": "buy", "minBeds": 4, "minPrice": 400000, "maxPrice": 700000, "homeTypes": ["houses"], "fetchDetails": true, "maxItems": 300 }
```

**Scrape several metros in one run, cheapest first**

```json
{ "locations": ["Miami, FL", "Tampa, FL", "Orlando, FL"], "operation": "buy", "sortBy": "lowPrice", "maxItems": 1500 }
```

### 🤖 Copy to your AI assistant

Paste this block into Claude, ChatGPT, or Cursor to give it full context about this scraper:

```
You have access to the Zillow Scraper on Apify: silentflow/zillow-scraper

It scrapes U.S. residential listings (for sale, for rent, recently sold) from Zillow by location.

Input schema:
- location (string): a city, ZIP, neighborhood, county, state, or address. Required unless locations is set.
- locations (array of strings): scrape several locations in one run; overrides location.
- operation (string): "buy" | "rent" | "sold". Default "buy".
- maxItems (integer, required): max listings to return. Default 100. No hard cap from the source.
- minPrice, maxPrice (integer): price range (per month for rent). 0 = any.
- minBeds, maxBeds (integer): bedroom range. 0 = any.
- minBaths (number): minimum bathrooms.
- homeTypes (array): "houses","townhomes","multifamily","condos","land","apartments","manufactured".
- sortBy (string): "newest","relevance","lowPrice","highPrice","bedrooms","bathrooms","sqft","lotSize","yearBuilt".
- locationType (string): force "city"|"zipcode"|"neighborhood"|"county"|"state"; auto-detects by default.
- fetchDetails (boolean, default false): enrich each listing with price/tax history, schools, lot facts, HOA, and agent contact.

Output per listing (flat JSON): zpid, url, operation, statusText, homeStatus, homeType, price, currency,
pricePerSqft, beds, baths, livingArea, lotAreaValue, lotAreaUnit, address{streetAddress,city,state,zipcode},
latitude, longitude, daysOnZillow, zestimate, rentZestimate, taxAssessedValue, priceChange, datePriceChanged,
listingTypes, brokerName, photos[], and (for rentals) buildingName/minBaseRent/maxBaseRent/units.
With fetchDetails, a details object adds description, yearBuilt, lotSize, parcelNumber, heating/cooling/appliances,
agentName/agentPhone/agentEmail/brokerName/mlsId, priceHistory[], taxHistory[], schools[].

Pay per result. Proxies included. Use apify-client for Python or JS.
```

### 💻 Integrations

#### Build a comps list for an investor (Python)

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("silentflow/zillow-scraper").call(run_input={
    "location": "78745",
    "operation": "sold",
    "maxItems": 1000,
    "fetchDetails": True,
})

comps = []
for home in client.dataset(run["defaultDatasetId"]).iterate_items():
    comps.append({
        "address": home["address"]["streetAddress"],
        "soldPrice": home.get("price"),
        "soldDate": home.get("dateSold"),
        "perSqft": home.get("pricePerSqft"),
        "beds": home.get("beds"),
    })

comps.sort(key=lambda c: c["soldPrice"] or 0)
print(f"{len(comps)} comparable sales")
```

#### Build an agent lead list (JavaScript)

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

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

const run = await client.actor('silentflow/zillow-scraper').call({
  location: 'Denver, CO',
  operation: 'buy',
  fetchDetails: true,
  maxItems: 500,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();

const leads = items
  .map(h => h.details && ({
    agent: h.details.agentName,
    phone: h.details.agentPhone,
    brokerage: h.details.brokerName,
    listing: h.url,
  }))
  .filter(Boolean);

console.log(`${leads.length} agent leads ready for outreach`);
```

#### Export straight to CSV (Apify CLI)

```bash
apify call silentflow/zillow-scraper \
  --input '{"location":"Phoenix, AZ","operation":"rent","maxItems":1000}' \
  --output-dataset \
  | apify datasets get-items --format csv > phoenix-rentals.csv
```

### 📈 Performance

| Metric | Value |
|--------|-------|
| Markets | All U.S. cities, ZIPs, neighborhoods, counties, states |
| Operations | For sale, for rent, recently sold |
| Result cap | None from the source. Set `maxItems` to whatever you need. |
| Coverage | Whole-metro, not the capped browser page |
| Detail enrichment | Optional, per listing |
| Proxies | Residential, included |
| Reliability | High |

### 💾 Data export

Every run produces a dataset you can download from the Apify console as **JSON, CSV, Excel, XML, or RSS**, or pull programmatically:

```
https://api.apify.com/v2/datasets/DATASET_ID/items?format=csv&token=YOUR_TOKEN
```

Schedule runs, trigger them by API, or connect the output to Make, Zapier, Google Sheets, or your own database.

### 💡 Tips for best results

1. **Use a clear location.** `Austin, TX` beats `Austin`. Add the state to avoid matching the wrong city. For a single property, paste the full address.
2. **Filter at the source.** Set `minPrice`, `minBeds`, and `homeTypes` in the input instead of pulling everything and filtering later. You get exactly what you need and nothing extra.
3. **Turn on `fetchDetails` only when you need depth.** The base listing already has price, beds, baths, photos, and valuations. Add detail when you want price history, schools, lot facts, or agent contact.
4. **Run several markets at once.** Pass a `locations` array to cover a whole region in one run instead of starting one job per city.
5. **For sold comps, always enable `fetchDetails`.** Zillow hides the sold price on the result card, so detail enrichment fills it in along with the full sale and tax history.

### ❓ FAQ

**What does this scraper extract?**
Residential listings from Zillow for sale, for rent, and recently sold, with price, beds, baths, square footage, lot size, location, photos, Zestimate, days on market, and listing status. With detail enrichment it also returns description, price and tax history, assigned schools, construction and lot facts, HOA, and the listing agent's contact.

**How do I search? Do I need a Zillow URL?**
No URL needed. Type a city, ZIP, neighborhood, county, state, or address. The scraper resolves it for you.

**Can I scrape several locations in one run?**
Yes. Use the `locations` array. Each location is searched and the results are combined and de-duplicated.

**Is there a limit on how many homes I can get?**
No hard cap from the source. The scraper covers a whole market, not the capped page the browser shows. Set `maxItems` to your target.

**Do I need a Zillow account or login?**
No. The scraper reads publicly available listing data. No login, no API key.

**How fresh is the data?**
Each run reads Zillow live, so you get the current listings and prices at the moment you run it.

**Why is the price empty on some sold homes?**
Zillow does not show the sold price on the search card. Turn on `fetchDetails` and the sold price is filled in from the property's price history.

**Can I get the listing agent's contact?**
Yes, with `fetchDetails`. You get the agent's name, phone, and brokerage. Email is included when the listing exposes it publicly.

**What about apartment buildings with many units?**
Buildings return as one record with the building name, availability, and per-unit pricing (beds and rent) instead of a single price.

### ⚖️ Legal

This Actor extracts publicly available data from Zillow. It does not bypass any login, paywall, or CAPTCHA. Users are responsible for complying with Zillow's terms of service and applicable laws in their jurisdiction. The data returned is informational; verify accuracy for regulated use cases such as lending, appraisal, or compliance.

### 📬 Support

Need something this scraper doesn't do yet? We ship features fast.

- Feature requests go straight to our backlog
- Enterprise needs? We do custom integrations and high-volume plans
- Pricing questions? Check the Monetization tab on the Actor page

Response time: usually under 24 hours.

Check out our other scrapers: [silentflow on Apify](https://apify.com/silentflow)

# Actor input Schema

## `location` (type: `string`):

City, neighborhood, ZIP code, or address to search. Ignored when Locations is set.

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

Search several locations in one run. When set, this overrides Location.

## `locationType` (type: `string`):

Leave on Auto-detect unless a location name is ambiguous.

## `operation` (type: `string`):

Which market to search.

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

Maximum number of listings to return.

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

Minimum price (per month for rent). 0 for any.

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

Maximum price (per month for rent). 0 for any.

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

Minimum number of bedrooms.

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

Maximum number of bedrooms. 0 for any.

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

Minimum number of bathrooms.

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

Restrict to specific property types. Leave empty for all.

## `sortBy` (type: `string`):

Result ordering.

## `fetchDetails` (type: `boolean`):

Enrich each listing with detail-page data (description, year built, lot, agent, HOA, tax rate). Slower.

## `debugMode` (type: `boolean`):

Verbose logging for troubleshooting.

## Actor input object example

```json
{
  "location": "Austin, TX",
  "locationType": "",
  "operation": "buy",
  "maxItems": 100,
  "minPrice": 0,
  "maxPrice": 0,
  "minBeds": 0,
  "maxBeds": 0,
  "minBaths": 0,
  "sortBy": "newest",
  "fetchDetails": false,
  "debugMode": false
}
```

# Actor output Schema

## `listings` (type: `string`):

All scraped listings from the default dataset.

# 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 = {
    "location": "Austin, TX"
};

// Run the Actor and wait for it to finish
const run = await client.actor("silentflow/zillow-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "location": "Austin, TX" }

# Run the Actor and wait for it to finish
run = client.actor("silentflow/zillow-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 '{
  "location": "Austin, TX"
}' |
apify call silentflow/zillow-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Zillow Scraper",
        "description": "Scrape Zillow listings by city, ZIP, or neighborhood. Pull homes for sale, for rent, and recently sold with prices, beds, baths, photos, and Zestimates, plus full detail: price and tax history, schools, lot facts, and agent contacts. No 1,000-result cap. Export to CSV, JSON, or Excel for comps.",
        "version": "1.0",
        "x-build-id": "OJ9WefTraHyM36Lna"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/silentflow~zillow-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-silentflow-zillow-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/silentflow~zillow-scraper/runs": {
            "post": {
                "operationId": "runs-sync-silentflow-zillow-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/silentflow~zillow-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-silentflow-zillow-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",
                "required": [
                    "maxItems"
                ],
                "properties": {
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City, neighborhood, ZIP code, or address to search. Ignored when Locations is set."
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Search several locations in one run. When set, this overrides Location.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locationType": {
                        "title": "Location type",
                        "enum": [
                            "",
                            "city",
                            "neighborhood",
                            "zipcode",
                            "county",
                            "state"
                        ],
                        "type": "string",
                        "description": "Leave on Auto-detect unless a location name is ambiguous.",
                        "default": ""
                    },
                    "operation": {
                        "title": "Operation",
                        "enum": [
                            "buy",
                            "rent",
                            "sold"
                        ],
                        "type": "string",
                        "description": "Which market to search.",
                        "default": "buy"
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of listings to return.",
                        "default": 100
                    },
                    "minPrice": {
                        "title": "Min price",
                        "type": "integer",
                        "description": "Minimum price (per month for rent). 0 for any.",
                        "default": 0
                    },
                    "maxPrice": {
                        "title": "Max price",
                        "type": "integer",
                        "description": "Maximum price (per month for rent). 0 for any.",
                        "default": 0
                    },
                    "minBeds": {
                        "title": "Min bedrooms",
                        "type": "integer",
                        "description": "Minimum number of bedrooms.",
                        "default": 0
                    },
                    "maxBeds": {
                        "title": "Max bedrooms",
                        "type": "integer",
                        "description": "Maximum number of bedrooms. 0 for any.",
                        "default": 0
                    },
                    "minBaths": {
                        "title": "Min bathrooms",
                        "type": "number",
                        "description": "Minimum number of bathrooms.",
                        "default": 0
                    },
                    "homeTypes": {
                        "title": "Home types",
                        "type": "array",
                        "description": "Restrict to specific property types. Leave empty for all.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "houses",
                                "townhomes",
                                "multifamily",
                                "condos",
                                "land",
                                "apartments",
                                "manufactured"
                            ],
                            "enumTitles": [
                                "Houses",
                                "Townhomes",
                                "Multi-family",
                                "Condos/co-ops",
                                "Lots/Land",
                                "Apartments",
                                "Manufactured"
                            ]
                        }
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "newest",
                            "relevance",
                            "lowPrice",
                            "highPrice",
                            "bedrooms",
                            "bathrooms",
                            "sqft",
                            "lotSize",
                            "yearBuilt"
                        ],
                        "type": "string",
                        "description": "Result ordering.",
                        "default": "newest"
                    },
                    "fetchDetails": {
                        "title": "Fetch details",
                        "type": "boolean",
                        "description": "Enrich each listing with detail-page data (description, year built, lot, agent, HOA, tax rate). Slower.",
                        "default": false
                    },
                    "debugMode": {
                        "title": "Debug mode",
                        "type": "boolean",
                        "description": "Verbose logging for troubleshooting.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
