# Zillow Search Scraper (`scrapapi/zillow-search-scraper`) Actor

🏠 Zillow Search Scraper turns Zillow search results into structured real estate data—prices, beds/baths, sqft, address, status, photos & links. 🔎 Ideal for comps, lead gen & market analysis. ⚡ Fast, reliable, anti-blocking. 🚀 For investors, agents & analysts.

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

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#rental-actors

## 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 Search Scraper

The Zillow Search Scraper is a fast, reliable Zillow web scraping tool that turns Zillow search results into structured real estate data for analysis and automation. It solves the pain of manually collecting listing details by programmatically extracting prices, beds/baths, square footage, addresses, statuses, photos, and links from search pages. Built for investors, agents, analysts, and developers, this Zillow listings scraper scales from one-off comps to large market studies—an effective Zillow API alternative for Zillow search export workflows.

### What data / output can you get?

Below are example fields pushed to the Apify dataset for each listing. Values are illustrative and align with real output keys.

| Data field | Description | Example value |
| --- | --- | --- |
| zpid | Zillow Property ID (stringified) | "55826232" |
| id | Same as zpid (for convenience) | "55826232" |
| price | Formatted price string | "$649,000" |
| unformattedPrice | Numeric price value parsed from price | 649000 |
| address | Full address string | "3810 Hawthorne Ave, Dallas, TX 75219" |
| addressStreet | Street address | "3810 Hawthorne Ave" |
| addressCity | City | "Dallas" |
| addressState | State (abbrev) | "TX" |
| addressZipcode | ZIP code | "75219" |
| beds | Number of bedrooms | 3 |
| baths | Number of bathrooms | 2.5 |
| area | Square footage | 2622 |
| detailUrl | Full URL to the listing detail page | "https://www.zillow.com/homedetails/..." |
| statusType | Status code (e.g., FOR_SALE) | "FOR_SALE" |
| statusText | Human-readable status text | "House for sale" |
| imgSrc | Main image URL | "https://photos.zillowstatic.com/..." |
| latLong | Geo coordinates object | {"latitude": 32.822216, "longitude": -96.811325} |
| zestimate | Zillow’s estimated value (if present) | 994000 |

Bonus metadata includes fields like palsId, rawHomeStatusCd, marketingStatusSimplifiedCd, providerListingId, isUndisclosedAddress, streetViewURL, hasImage, has3DModel, hasVideo, hdpData, carouselPhotosComposable, foundFromSearchUrl, and zoomQuadrantSequence.

Results are saved to your Apify dataset in real time. You can export data to JSON or CSV directly from the dataset.

### Key features

- ⚡ Dynamic zoom API pagination  
  Use “Pagination with dynamic zoom increase” to split large map areas into quadrants and go beyond normal Zillow pagination caps—great for big markets and complete coverage.

- 🧭 HTML pagination fallback  
  When the API method isn’t usable (e.g., keyword-only URLs without searchQueryState), the scraper switches to robust HTML parsing of the search pages.

- 🛡️ Intelligent proxy management  
  Automatic fallback from direct requests to datacenter and then residential proxies (with retries), helping avoid blocks and maintain uptime.

- 💾 Live dataset saving  
  Listings are pushed to the Apify dataset as they’re found—so you don’t lose progress if a run stops unexpectedly.

- 📦 Bulk input support  
  Feed multiple search URLs or keywords in one run for automated Zillow search export across cities, ZIPs, or regions.

- 🎯 Configurable limits  
  Control scale with maxItems (1–10,000). Map Markers mode safely caps per-URL output to ~500 results.

- 🧑‍💻 Developer-friendly, Python-based  
  Implemented in Python for easy integration into your pipelines. Advanced users can pass sortOrder via API (honored at runtime) for custom sorting.

- 🔍 Detailed logging  
  Clear, incremental progress logs with periodic “Saved X/Y” snapshots for monitoring.

### How to use Zillow Search Scraper - step by step

1. Sign in to your Apify account and open the Apify Console.
2. Go to Actors and locate “zillow-search-scraper”.
3. Add input:
   - Paste Zillow search URLs (recommended: full URLs with searchQueryState) or keywords like “dallas-tx”, “new-york-ny” into searchUrls.
4. Choose the extractionMethod:
   - PAGINATION_WITH_DYNAMIC_ZOOM_INCREASE for large result sets.
   - PAGINATION_WITHOUT_ZOOMING_IN for HTML-based pagination.
   - MAP_MARKERS for quick map-marker snapshots (~500 results cap per URL).
5. Set maxItems to control how many listings you want per search URL.
6. Configure proxyConfiguration if needed (by default, it starts without a proxy and can auto-fallback).
7. Run the actor and monitor logs. Results are saved live to the dataset.
8. Download your results from the “Dataset” tab—export to JSON or CSV for analysis or upload.

Pro tip: Advanced users can provide a sortOrder (via API only) and the actor will apply it to eligible URLs. You can also control pacing via a delay parameter when invoking programmatically.

### Use cases

| Use case | Description |
| --- | --- |
| Real estate market research | Aggregate for-sale and rental inventory to benchmark pricing, beds/baths, and sqft across neighborhoods for trend analysis. |
| Lead generation for agents | Build targeted lead lists by exporting structured listing data and links for outreach. |
| Investment screening | Rapidly evaluate comps and shortlist properties by price, area, and status to streamline underwriting. |
| Rental market monitoring | Track rental availability and pricing using statusType/statusText for a Zillow rental scraper workflow. |
| Competitor & broker tracking | Monitor listing volumes and changes to stay ahead of market shifts. |
| Data enrichment pipeline (API) | Feed normalized listing data into internal databases or analytics stacks for Zillow property data scraping workflows. |
| Academic & urban research | Collect longitudinal datasets for housing studies and policy analysis using consistent Zillow search export runs. |

### Why choose Zillow Search Scraper?

This production-ready Zillow data scraper is built for precision, scale, and reliability—ideal for teams who value structured outputs and stable automation.

- ✅ Accurate, normalized output with both formatted and numeric pricing, detailed addresses, and geolocation.
- 🚀 Scales to large markets using dynamic zoom to bypass normal search caps.
- 🧑‍💻 Developer access: Python-based actor, honors advanced parameters like sortOrder when passed via API.
- 🔄 Bulk-friendly: process multiple search URLs or keywords in one automated Zillow search scraper workflow.
- 🔌 Easy exports: fetch results from the Apify dataset and scrape Zillow listings to CSV or JSON for downstream use.
- 🛡️ Anti-blocking built-in: automatic proxy fallback improves stability vs. extension-based or ad hoc tools.
- 💼 Reliable infrastructure: live-saving to datasets and clear logging reduce operational risk.

In short, it’s a robust Zillow scraping service alternative to unstable browser extensions—built for repeatable Zillow search results scraper jobs.

### Is it legal / ethical to use Zillow Search Scraper?

Yes—when used responsibly. This actor collects data from publicly available Zillow search pages and does not access private or password-protected content.

Guidelines for compliant use:
- Only collect public listing data and respect Zillow’s terms of service.
- Ensure your use complies with applicable laws (e.g., GDPR/CCPA).
- Avoid spam and misuse; use data for analysis and research purposes.
- Consult your legal team for edge cases or jurisdiction-specific requirements.

### Input parameters & output format

#### Example JSON input
```json
{
  "searchUrls": [
    "https://www.zillow.com/dallas-tx/?category=SEMANTIC&searchQueryState=%7B%22isMapVisible%22%3Atrue%2C%22mapBounds%22%3A%7B%22north%22%3A33.10483509834637%2C%22south%22%3A32.53008985410089%2C%22east%22%3A-96.3544578671875%2C%22west%22%3A-97.2004051328125%7D%2C%22filterState%22%3A%7B%22sort%22%3A%7B%22value%22%3A%22globalrelevanceex%22%7D%7D%2C%22isListVisible%22%3Atrue%2C%22usersSearchTerm%22%3A%22Dallas%2C%20TX%22%2C%22category%22%3A%22cat1%22%2C%22regionSelection%22%3A%5B%7B%22regionId%22%3A38128%2C%22regionType%22%3A6%7D%5D%7D"
  ],
  "extractionMethod": "PAGINATION_WITH_DYNAMIC_ZOOM_INCREASE",
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

| Field | Type | Required | Default | Description |
| --- | --- | --- | --- | --- |
| searchUrls | array | Yes | — | List of Zillow search URLs (full URLs with searchQueryState recommended) or keywords/locations (e.g., "dallas-tx"). Supports bulk input. |
| extractionMethod | string | No | PAGINATION\_WITH\_DYNAMIC\_ZOOM\_INCREASE | Choose the scraping method: PAGINATION\_WITH\_DYNAMIC\_ZOOM\_INCREASE, PAGINATION\_WITHOUT\_ZOOMING\_IN, or MAP\_MARKERS. |
| maxItems | integer | No | 20 | Maximum number of property listings to scrape (1–10,000). |
| proxyConfiguration | object | No | {"useApifyProxy": false} | Proxy settings. By default, runs without a proxy. On blocks, it can fallback to datacenter, then residential with retries. |

Note for developers: At runtime, the actor also honors sortOrder (if provided via API) and uses a delay setting internally for pacing.

#### Example JSON output

Each item in the dataset is a normalized listing object:

```json
{
  "zpid": "55826232",
  "palsId": null,
  "id": "55826232",
  "rawHomeStatusCd": "FOR_SALE",
  "marketingStatusSimplifiedCd": "FOR_SALE",
  "providerListingId": "*APID55826232*",
  "imgSrc": "https://photos.zillowstatic.com/...",
  "hasImage": true,
  "detailUrl": "https://www.zillow.com/homedetails/55826232_zpid/",
  "statusType": "FOR_SALE",
  "statusText": "House for sale",
  "countryCurrency": "$",
  "price": "$649,000",
  "unformattedPrice": 649000,
  "address": "3810 Hawthorne Ave, Dallas, TX 75219",
  "addressStreet": "3810 Hawthorne Ave",
  "addressCity": "Dallas",
  "addressState": "TX",
  "addressZipcode": "75219",
  "isUndisclosedAddress": false,
  "beds": 3,
  "baths": 2.5,
  "area": 2622,
  "latLong": { "latitude": 32.822216, "longitude": -96.811325 },
  "zestimate": 994000,
  "has3DModel": false,
  "hasVideo": false,
  "hdpData": {},
  "carouselPhotosComposable": {
    "baseUrl": "https://photos.zillowstatic.com/fp/{photoKey}-p_e.jpg",
    "communityBaseUrl": null,
    "photoData": [],
    "communityPhotoData": null,
    "isStaticUrls": false
  },
  "foundOnSearchPage": 1,
  "foundFromSearchUrl": "https://www.zillow.com/dallas-tx/?category=SEMANTIC&searchQueryState=...",
  "zoomQuadrantSequence": []
}
```

Some fields may be null or empty depending on availability in the source (e.g., palsId, certain media fields).

### FAQ

#### Do I need proxies to run this Zillow scraper?

No by default. The actor starts with no proxy. If Zillow blocks requests, it automatically falls back to datacenter and then residential proxies with retries. You can also explicitly set proxyConfiguration to use Apify Proxy from the start.

#### Which extraction method should I pick?

For large markets, use PAGINATION\_WITH\_DYNAMIC\_ZOOM\_INCREASE to go beyond normal caps by splitting the map into quadrants. Use PAGINATION\_WITHOUT\_ZOOMING\_IN for HTML-based pagination when API-style calls are blocked. MAP\_MARKERS is best for quick snapshots, limited to roughly 500 results per search URL.

#### Can I scrape multiple cities or ZIP codes at once?

Yes. Add multiple entries to searchUrls—either full Zillow search URLs (recommended) or keywords like “dallas-tx”. The actor processes them in bulk as an automated Zillow search scraper.

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

You control this with maxItems (1–10,000). In MAP\_MARKERS mode, results are limited to roughly 500 per search URL by design. Dynamic zoom helps collect more complete sets on large areas.

#### What data fields are included in the output?

Core fields include zpid, id, price, unformattedPrice, address components, beds, baths, area, detailUrl, statusType/statusText, imgSrc, latLong, zestimate, plus metadata like hdpData and carouselPhotosComposable. See the “What data / output can you get?” section for examples.

#### Can I use this as a Zillow rental scraper or for-sale scraper?

Yes. The scraper captures statusType and statusText from search results, so it works for both rentals and for-sale listings depending on your search URLs and filters.

#### How do I export results—can I scrape Zillow listings to CSV?

After the run, open the dataset and export your results to JSON or CSV. This supports seamless Zillow search export into analytics or CRMs.

#### Is there a trial or pricing?

A flat monthly price of $19.99 is available with 120 trial minutes to test the actor before committing to larger runs.

#### Does this support developers and Python integration?

Yes. The actor is implemented in Python and runs on the Apify platform. You can automate runs and consume dataset exports programmatically to build a Zillow scraper Python workflow or pipeline.

### Closing thoughts

Zillow Search Scraper is built to turn Zillow search results into structured, analysis-ready real estate data at scale. With dynamic zoom API pagination, robust HTML fallback, live-saving, and proxy resilience, it’s ideal for investors, agents, analysts, and researchers. Developers can integrate it into automated pipelines, export Zillow data to CSV/JSON, and operate it as a dependable Zillow API alternative. Start extracting smarter Zillow property insights with a reliable, automated Zillow search results scraper today.

# Actor input Schema

## `searchUrls` (type: `array`):

List of Zillow search URLs (full URLs with searchQueryState) or keywords/locations to search. Supports bulk input. Enter full Zillow URLs (recommended) or keywords like 'dallas-tx', 'new-york-ny'. For PAGINATION\_WITH\_ZOOM\_IN method, full URLs with searchQueryState are recommended.

## `extractionMethod` (type: `string`):

Choose the scraping method. Dynamic zoom can go beyond Zillow's normal pagination cap by splitting the map into smaller quadrants (best for large result sets). Pagination without zooming uses HTML pages (good when API is blocked). Map markers is limited to roughly 500 results per search URL.

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

Maximum number of property listings to scrape (1-10000).

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

Proxy settings. By default, requests are sent without proxy. If Zillow blocks requests, the actor will automatically fallback to datacenter proxy, then residential proxy with 3 retries.

## Actor input object example

```json
{
  "searchUrls": [
    "https://www.zillow.com/dallas-tx/?category=SEMANTIC&searchQueryState=%7B%22isMapVisible%22%3Atrue%2C%22mapBounds%22%3A%7B%22north%22%3A33.10483509834637%2C%22south%22%3A32.53008985410089%2C%22east%22%3A-96.3544578671875%2C%22west%22%3A-97.2004051328125%7D%2C%22filterState%22%3A%7B%22sort%22%3A%7B%22value%22%3A%22globalrelevanceex%22%7D%7D%2C%22isListVisible%22%3Atrue%2C%22usersSearchTerm%22%3A%22Dallas%2C%20TX%22%2C%22category%22%3A%22cat1%22%2C%22regionSelection%22%3A%5B%7B%22regionId%22%3A38128%2C%22regionType%22%3A6%7D%5D%7D"
  ],
  "extractionMethod": "PAGINATION_WITH_DYNAMIC_ZOOM_INCREASE",
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "searchUrls": [
        "https://www.zillow.com/dallas-tx/?category=SEMANTIC&searchQueryState=%7B%22isMapVisible%22%3Atrue%2C%22mapBounds%22%3A%7B%22north%22%3A33.10483509834637%2C%22south%22%3A32.53008985410089%2C%22east%22%3A-96.3544578671875%2C%22west%22%3A-97.2004051328125%7D%2C%22filterState%22%3A%7B%22sort%22%3A%7B%22value%22%3A%22globalrelevanceex%22%7D%7D%2C%22isListVisible%22%3Atrue%2C%22usersSearchTerm%22%3A%22Dallas%2C%20TX%22%2C%22category%22%3A%22cat1%22%2C%22regionSelection%22%3A%5B%7B%22regionId%22%3A38128%2C%22regionType%22%3A6%7D%5D%7D"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapapi/zillow-search-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 = {
    "searchUrls": ["https://www.zillow.com/dallas-tx/?category=SEMANTIC&searchQueryState=%7B%22isMapVisible%22%3Atrue%2C%22mapBounds%22%3A%7B%22north%22%3A33.10483509834637%2C%22south%22%3A32.53008985410089%2C%22east%22%3A-96.3544578671875%2C%22west%22%3A-97.2004051328125%7D%2C%22filterState%22%3A%7B%22sort%22%3A%7B%22value%22%3A%22globalrelevanceex%22%7D%7D%2C%22isListVisible%22%3Atrue%2C%22usersSearchTerm%22%3A%22Dallas%2C%20TX%22%2C%22category%22%3A%22cat1%22%2C%22regionSelection%22%3A%5B%7B%22regionId%22%3A38128%2C%22regionType%22%3A6%7D%5D%7D"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapapi/zillow-search-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 '{
  "searchUrls": [
    "https://www.zillow.com/dallas-tx/?category=SEMANTIC&searchQueryState=%7B%22isMapVisible%22%3Atrue%2C%22mapBounds%22%3A%7B%22north%22%3A33.10483509834637%2C%22south%22%3A32.53008985410089%2C%22east%22%3A-96.3544578671875%2C%22west%22%3A-97.2004051328125%7D%2C%22filterState%22%3A%7B%22sort%22%3A%7B%22value%22%3A%22globalrelevanceex%22%7D%7D%2C%22isListVisible%22%3Atrue%2C%22usersSearchTerm%22%3A%22Dallas%2C%20TX%22%2C%22category%22%3A%22cat1%22%2C%22regionSelection%22%3A%5B%7B%22regionId%22%3A38128%2C%22regionType%22%3A6%7D%5D%7D"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scrapapi/zillow-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Zillow Search Scraper",
        "description": "🏠 Zillow Search Scraper turns Zillow search results into structured real estate data—prices, beds/baths, sqft, address, status, photos & links. 🔎 Ideal for comps, lead gen & market analysis. ⚡ Fast, reliable, anti-blocking. 🚀 For investors, agents & analysts.",
        "version": "0.1",
        "x-build-id": "yntcFy5zfH7ASJ4v9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapapi~zillow-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapapi-zillow-search-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/scrapapi~zillow-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapapi-zillow-search-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/scrapapi~zillow-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapapi-zillow-search-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": [
                    "searchUrls"
                ],
                "properties": {
                    "searchUrls": {
                        "title": "Search URLs or Keywords",
                        "type": "array",
                        "description": "List of Zillow search URLs (full URLs with searchQueryState) or keywords/locations to search. Supports bulk input. Enter full Zillow URLs (recommended) or keywords like 'dallas-tx', 'new-york-ny'. For PAGINATION_WITH_ZOOM_IN method, full URLs with searchQueryState are recommended.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "extractionMethod": {
                        "title": "Items extraction method",
                        "enum": [
                            "PAGINATION_WITH_DYNAMIC_ZOOM_INCREASE",
                            "PAGINATION_WITHOUT_ZOOMING_IN",
                            "MAP_MARKERS"
                        ],
                        "type": "string",
                        "description": "Choose the scraping method. Dynamic zoom can go beyond Zillow's normal pagination cap by splitting the map into smaller quadrants (best for large result sets). Pagination without zooming uses HTML pages (good when API is blocked). Map markers is limited to roughly 500 results per search URL.",
                        "default": "PAGINATION_WITH_DYNAMIC_ZOOM_INCREASE"
                    },
                    "maxItems": {
                        "title": "Maximum Items",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of property listings to scrape (1-10000).",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. By default, requests are sent without proxy. If Zillow blocks requests, the actor will automatically fallback to datacenter proxy, then residential proxy with 3 retries."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
