# Zillow Real Estate Listings (`truefetch/zillow-real-estate-listings`) Actor

Search Zillow real estate listings by city, ZIP, state, or address. Collect sale, rent, and sold property data with prices, beds, baths, square footage, images, location details, and source URLs.

- **URL**: https://apify.com/truefetch/zillow-real-estate-listings.md
- **Developed by:** [TrueFetch](https://apify.com/truefetch) (community)
- **Categories:** Real estate, Lead generation, Agents
- **Stats:** 13 total users, 4 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.70 / 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

> **Affiliate disclosure:** Apify links on this page may include referral parameters. If you sign up through one of these links, TrueFetch may earn a commission from Apify at no extra cost to you. Pricing, features, and Actor access are unaffected.

[![Zillow Real Estate Listings](https://img.shields.io/badge/Zillow%20Listings-1B4F9A?style=for-the-badge&logoColor=white)](https://apify.com/truefetch/zillow-real-estate-listings?fpr=aiagentapi)
[![Real Estate Data](https://img.shields.io/badge/Real%20Estate%20Listings-1F8A70?style=for-the-badge)](https://apify.com/truefetch/zillow-real-estate-listings?fpr=aiagentapi)
[![Pay per Result](https://img.shields.io/badge/%2414.00%20per%201%2C000%20listings-2E8B57?style=for-the-badge)](https://apify.com/truefetch/zillow-real-estate-listings?fpr=aiagentapi)
[![No Cookies](https://img.shields.io/badge/No%20Login%20%7C%20No%20Cookies-555555?style=for-the-badge)](https://apify.com/truefetch/zillow-real-estate-listings?fpr=aiagentapi)
[![Telegram Support](https://img.shields.io/badge/Telegram-Support-26A5E4?style=for-the-badge&logo=telegram&logoColor=white)](https://t.me/AiAgentApi)
[![Telegram Group](https://img.shields.io/badge/Telegram-Group-26A5E4?style=for-the-badge&logo=telegram&logoColor=white)](https://t.me/Apify_Actor)

## Zillow Real Estate Listings — Zillow Property Data API

**Search Zillow — the United States' most-visited real estate marketplace — for active listings, recent sales, and rental properties across the United States and Canada, and return structured real estate data in one Apify Actor run.** Results include prices, listing status, property type, descriptions, images, agent or agency details, and source URLs as clean JSON / CSV / Excel. No platform login, cookies, or API keys required.

> **TL;DR (40-word answer):** Zillow Real Estate Listings is a no-login Apify Actor that returns 40+ structured fields per Zillow property listing from the United States and Canada at **$14.00 per 1,000 results**, with location-aware inputs, managed reliability, and JSON / CSV / Excel export.

> **What it is NOT:** Zillow Real Estate Listings is _not_ Zillow Premier Agent, a Zestimate provider, home loan originator, closing service, or listing publishing tool — it reads public Zillow listing pages and returns structured listing data only.

> **Zillow Real Estate Listings is an Apify Actor for collecting public property listing data from Zillow across the United States and Canada.** Search by location, choose listing status such as `for_sale`, `for_rent`, or `sold`, and export a dataset with price, address, property type, media, agent metadata, and source URL. Built for property market research, investment screening, competitor benchmarking, CRM enrichment, and AI agents using the Apify API or MCP. Maintained by TrueFetch on the Apify Store.

---

### 💼 Why choose Zillow Real Estate Listings

**Zillow Real Estate Listings is best for** US and Canada property investors, home shoppers comparing market listings, proptech teams building valuation tools, and AI agents that need structured Zillow data at scale.

- **🌍 Direct Zillow coverage for the United States and Canada** — collect for-sale, for-rent, and recently sold listings from Zillow with location-aware inputs covering all major US metros, neighborhoods, postal codes, and Canadian cities where Zillow operates.
- **🏠 40+ fields per listing** — title, listing type, property type, price, currency, bedrooms, bathrooms, area, address, location, images, agent or agency fields, and source URLs when available.
- **🛡️ Managed reliability built in** — request retries, proxy-aware collection, deduplication, and consistent dataset output are handled by the Actor.
- **📊 Unified export format** — use JSON, JSONL, CSV, Excel, XML, RSS, or the Apify dataset API without building your own parser.
- **⚡ Pay-per-result, not per-CPU** — flat **$14.00 per 1,000 successful listings** (`$0.0140` per result). Free Apify plan includes $5 monthly credits ≈ **~357 free listings per month**.

---

### 🚀 Quick Start — run in 3 steps

#### Run in Apify Console

1. **Open the Actor** — go to [Zillow Real Estate Listings on Apify](https://apify.com/truefetch/zillow-real-estate-listings?fpr=aiagentapi) and click **Try for free**.
2. **Configure inputs** — choose a `country`, enter a `location`, set `listing_type`, and choose `max_results`.
3. **Click Start** — the Actor streams real estate listings to the dataset. Export as JSON, JSONL, CSV, Excel, XML, RSS, or pull via the dataset API.

#### Run via Apify API

```bash
curl -X POST "https://api.apify.com/v2/acts/TrueFetch~zillow-real-estate-listings/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "country": "United States",
    "location": "Denver, CO",
    "listing_type": "for_sale",
    "max_results": 100
}'
````

#### Run via MCP (for AI agents)

Zillow Real Estate Listings is callable from Claude, ChatGPT, Cursor, and any MCP-compatible client through the [Apify MCP Server](https://docs.apify.com/platform/integrations/mcp?fpr=aiagentapi). Reference the Actor as `TrueFetch/zillow-real-estate-listings` and pass the same JSON input as above.

***

### ⚙️ Input parameters

| Parameter       | Type    | Required | Default    | Description                                                                               | Example         |
| --------------- | ------- | :------: | ---------- | ----------------------------------------------------------------------------------------- | --------------- |
| `country`       | string  |    ✅    | —          | Supported Zillow market. Choose United States or Canada.                                  | `United States` |
| `location`      | string  |    ✅    | —          | City, region, neighborhood, postal code, or address to search.                            | `Denver, CO`    |
| `max_results`   | integer |    ✅    | —          | Maximum number of real estate listings to return. Each successful listing is billed once. | `100`           |
| `listing_type`  | string  |    ❌    | `for_sale` | Listing status such as `for_sale`, `for_rent`, or `sold` where supported.                 | `for_sale`      |
| `property_type` | string  |    ❌    | empty      | Optional property type filter. Leave empty to include all supported property types.       | `house`         |

**Default behavior:** the Actor queries the supported source for the selected country and location, deduplicates by source URL or listing ID, and streams results to the default dataset.

```json
{
  "country": "United States",
  "location": "Denver, CO",
  "listing_type": "for_sale",
  "max_results": 100
}
```

***

### 📦 Output dataset

Each run writes structured real estate objects to the **default Apify dataset**, exportable as JSON, JSONL, CSV, Excel, XML, RSS, or via the dataset API.

| Field           | Type   | Always present? | Description                                                   | Example                                               |
| --------------- | ------ | :-------------: | ------------------------------------------------------------- | ----------------------------------------------------- |
| `platform`      | string |       ✅        | Source platform name.                                         | `Zillow`                                              |
| `source_url`    | string |       ✅        | Original listing URL for verification.                        | `https://example.com/listing/123`                     |
| `title`         | string |       ✅        | Listing title.                                                | `Modern 2 bedroom apartment`                          |
| `description`   | string |    optional     | Clean listing description when available.                     | `Bright apartment near transit with updated kitchen.` |
| `listing_id`    | string |    optional     | Platform listing identifier.                                  | `123456789`                                           |
| `listing_type`  | string |    optional     | `for_sale`, `for_rent`, or `sold`.                            | `for_sale`                                            |
| `property_type` | string |    optional     | House, apartment, condo, land, commercial, or similar.        | `house`                                               |
| `price`         | object |    optional     | Price value, text, and currency when available.               | `{"value": 750000, "currency": "USD"}`                |
| `beds`          | number |    optional     | Bedroom count.                                                | `3`                                                   |
| `baths`         | number |    optional     | Bathroom count.                                               | `2`                                                   |
| `area`          | object |    optional     | Floor area or lot area with unit.                             | `{"value": 1450, "unit": "sqft"}`                     |
| `address`       | object |    optional     | Structured address fields when available.                     | `{"city": "Denver", "region": "CO"}`                  |
| `location`      | string |    optional     | Human-readable location.                                      | `Denver, CO`                                          |
| `geo`           | object |    optional     | Latitude and longitude when available.                        | `{"lat": 39.7392, "lon": -104.9903}`                  |
| `image_urls`    | array  |    optional     | Deduplicated listing image URLs.                              | `["https://images.example.com/1.jpg"]`                |
| `agent`         | object |    optional     | Agent, agency, phone, email, or profile data when available.  | `{"name": "Jane Agent"}`                              |
| `official_url`  | string |    optional     | Official outbound URL when explicitly provided by the source. | `https://agency.example.com/listing/123`              |

#### Sample output

```json
{
  "platform": "Zillow",
  "source_url": "https://example.com/listing/123",
  "title": "Modern 2 bedroom apartment",
  "listing_type": "for_sale",
  "property_type": "apartment",
  "price": { "value": 750000, "currency": "USD", "text": "$750,000" },
  "beds": 2,
  "baths": 2,
  "location": "Denver, CO",
  "image_urls": ["https://images.example.com/property.jpg"]
}
```

***

### 💡 Use cases

#### For real estate investors and analysts

Track for-sale, for-rent, or recently sold Zillow listings in target US or Canadian locations, compare asking prices across neighborhoods, monitor property type availability, and export clean datasets for market trend analysis or portfolio screening.

#### For agencies and lead generation teams

Collect public Zillow listing metadata, agent or agency fields where available, source URLs, and location details to power prospecting campaigns, listing intelligence, and CRM enrichment workflows.

#### For property portals and data products

Use scheduled runs to refresh your Zillow listing feed. Deduplicate on `source_url` or `listing_id`, then push structured fields to your database, warehouse, or downstream data pipeline.

#### For AI agents and research assistants

Call this Actor through the Apify API or MCP server to answer US and Canada property market questions — price ranges, inventory levels, listing trends — with live Zillow listing data instead of stale training data.

***

### 💰 Pricing, limits, and performance

| Fact                        | Value                                             |
| --------------------------- | ------------------------------------------------- |
| Pricing model               | Pay-per-result (event: `result`)                  |
| Per-result price            | **$0.0140 per listing = $14.00 per 1,000**        |
| Free-tier monthly allowance | $5 Apify credits ≈ **~357 free listings / month** |
| Supported source            | Zillow                                            |
| Supported markets           | the United States and Canada                      |
| Output fields per listing   | **40+**                                           |
| Login / cookies required    | **No** — works without a platform account         |
| Export formats              | JSON, JSONL, CSV, Excel, XML, RSS, dataset API    |

You are billed only for **successfully delivered, deduplicated real estate listings**. Blocked requests, retries, and duplicates are not billed as result events.

***

### ⚖️ Compared with alternatives

| Capability                    | **Zillow Real Estate Listings** | Manual browsing |   In-house scraper   |
| ----------------------------- | :-----------------------------: | :-------------: | :------------------: |
| Structured listing dataset    |               ✅                |       ❌        |      you build       |
| No platform login required    |               ✅                |     varies      |        varies        |
| JSON / CSV / Excel export     |               ✅                |       ❌        |      you build       |
| Managed retries and stability |               ✅                |       ❌        |     you maintain     |
| Source URL for verification   |               ✅                |     manual      |      you build       |
| Pay-per-result pricing        |               ✅                |    time cost    | infrastructure + dev |
| Setup time to first result    |          < 60 seconds           |     manual      |    days to weeks     |

**Verdict.** Use Zillow Real Estate Listings when you need structured real estate listing data without building and maintaining platform-specific scraping infrastructure.

***

### ⚠️ Common mistakes to avoid

1. **Using a vague location.** Prefer city, postal code, neighborhood, or address formats supported by the selected platform.
2. **Expecting every field on every listing.** Some platforms or sellers do not publish agent, area, geo, or fee fields.
3. **Setting `max_results` too high for narrow searches.** A small neighborhood may not have enough matching listings.
4. **Confusing missing fields with parser failure.** If the raw source does not publish a field, the output should stay empty rather than invent a value.
5. **Ignoring source URLs.** Always keep `source_url` for verification and downstream deduplication.

***

### 🛠️ Troubleshooting

| Problem                               | Likely cause                                           | Fix                                                               |
| ------------------------------------- | ------------------------------------------------------ | ----------------------------------------------------------------- |
| Fewer results than `max_results`      | The source has fewer matching listings.                | Try a broader location, different listing type, or larger market. |
| Run returns 0 results                 | Location or listing type is too narrow or unsupported. | Try a major city, postal code, or a supported listing type.       |
| Some prices or agent fields are empty | The source listing did not publish those fields.       | Treat empty values as expected and filter downstream if needed.   |
| Results look unrelated                | Location format may not match the platform's routing.  | Use city/state, postal code, or a more precise address.           |
| Charge limit reached                  | Account-level run or monthly spend limit hit.          | Raise the run or monthly limit in your Apify settings.            |

***

### ❓ FAQ

#### What data does Zillow Real Estate Listings return?

It returns structured Zillow listing data including platform, source URL, title, description, listing type, property type, price, bedrooms, bathrooms, floor area, address, location, geo coordinates, images, and agent or agency details when published by Zillow.

#### How much does Zillow Real Estate Listings cost?

Zillow Real Estate Listings uses pay-per-result pricing at **$0.0140 per listing**, or **$14.00 per 1,000 listings**. The Apify Free plan includes $5 of monthly platform credits, covering approximately **357 free listings per month**.

#### Does Zillow Real Estate Listings require a login or cookies?

No. The Actor reads public Zillow listing pages without a Zillow account, cookies, or source-site API key. You only need an Apify token to invoke the Actor programmatically.

#### Can I export results to CSV or Excel?

Yes. Apify datasets can be exported as JSON, JSONL, CSV, Excel, XML, RSS, or consumed through the dataset API.

#### Does this return Zestimate or valuation data?

No. Zillow Real Estate Listings returns only structured data from public listing pages — price, property details, location, images, and agent fields when available. Zestimate values and private valuation data are not included.

***

### 🔌 Integrations

Use Zillow Real Estate Listings with:

- **Apify API** for backend ingestion.
- **MCP clients** such as Claude, ChatGPT, Cursor, and other AI tools through Apify MCP Server.
- **Make, n8n, Zapier, and webhooks** for no-code workflows.
- **CSV / Excel exports** for analysts and operations teams.
- **Data warehouses** such as BigQuery, Snowflake, Postgres, and internal BI systems.

***

### 🧱 Sister Actors from TrueFetch

#### Jobs

- [Best Job Listing](https://apify.com/truefetch/best-job-listing?fpr=aiagentapi)
- [Indeed Job Listing](https://apify.com/truefetch/indeed-job-listing?fpr=aiagentapi)
- [LinkedIn Job Listing](https://apify.com/truefetch/linkedin-job-listing?fpr=aiagentapi)
- [Glassdoor Job Listing](https://apify.com/truefetch/glassdoor-job-listing?fpr=aiagentapi)

#### Shopping & Deals

- [Amazon Product Listing](https://apify.com/truefetch/amazon-product-listing?fpr=aiagentapi)
- [eBay Listing](https://apify.com/truefetch/ebay-listing?fpr=aiagentapi)
- [Walmart Product Listing](https://apify.com/truefetch/walmart-product-listing?fpr=aiagentapi)
- [Target Product Listing](https://apify.com/truefetch/target-product-listing?fpr=aiagentapi)

#### Vehicles

- [AutoTrader Car Listing](https://apify.com/truefetch/autotrader-car-listing?fpr=aiagentapi)
- [Cars.com Car Listing](https://apify.com/truefetch/carscom-car-listing?fpr=aiagentapi)
- [Webmotors Car Listing](https://apify.com/truefetch/webmotors-car-listing?fpr=aiagentapi)

#### Real Estate

- [Global Real Estate Listings](https://apify.com/truefetch/global-real-estate-listings?fpr=aiagentapi)
- [Realtor Real Estate Listings](https://apify.com/truefetch/realtor-real-estate-listings?fpr=aiagentapi)
- [Rightmove Real Estate Listings](https://apify.com/truefetch/rightmove-real-estate-listings?fpr=aiagentapi)
- [Zoopla Real Estate Listings](https://apify.com/truefetch/zoopla-real-estate-listings?fpr=aiagentapi)
- [Domain Real Estate Listings](https://apify.com/truefetch/domain-real-estate-listings?fpr=aiagentapi)
- [Redfin Real Estate Listings](https://apify.com/truefetch/redfin-real-estate-listings?fpr=aiagentapi)

***

### 📞 Support, changelog, last updated

#### Support

- 💬 **Telegram group:** [t.me/Apify\_Actor](https://t.me/Apify_Actor)
- 📧 **Support:** [t.me/AiAgentApi](https://t.me/AiAgentApi)
- 📖 **Actor page & docs:** <https://apify.com/truefetch/zillow-real-estate-listings?fpr=aiagentapi>

Maintained by **TrueFetch** on the [Apify Store](https://apify.com/TrueFetch?fpr=aiagentapi).

> **Cost of doing nothing:** building and maintaining a Zillow data pipeline means constant upkeep as Zillow updates its interface and listing formats, monitoring for data gaps, and keeping extraction logic aligned with layout changes. Zillow Real Estate Listings replaces all of that with a managed, metered Actor that is always up to date.

#### Changelog

- **2026-06-02** — Updated TrueFetch real estate README, pricing copy, input descriptions, output schema summary, and platform-specific positioning.

***

### JSON-LD

```json
{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "WebSite",
      "@id": "https://apify.com/truefetch/zillow-real-estate-listings#website",
      "url": "https://apify.com/truefetch/zillow-real-estate-listings",
      "name": "Zillow Real Estate Listings",
      "publisher": { "@id": "https://apify.com/TrueFetch#publisher" }
    },
    {
      "@type": "SoftwareApplication",
      "@id": "https://apify.com/truefetch/zillow-real-estate-listings#software",
      "name": "Zillow Real Estate Listings",
      "applicationCategory": "BusinessApplication",
      "operatingSystem": "Cloud",
      "dateModified": "2026-06-03",
      "url": "https://apify.com/truefetch/zillow-real-estate-listings",
      "offers": {
        "@type": "Offer",
        "price": "0.0140",
        "priceCurrency": "USD",
        "description": "Pay per delivered real estate listing"
      },
      "author": { "@id": "https://apify.com/TrueFetch#author-TrueFetch" }
    },
    {
      "@type": "Organization",
      "@id": "https://apify.com/TrueFetch#publisher",
      "name": "TrueFetch",
      "url": "https://apify.com/TrueFetch"
    }
  ]
}
```

***

**Last Updated:** June 03, 2026

**Maintained by:** [TrueFetch](https://apify.com/TrueFetch?fpr=aiagentapi) · 💬 [Telegram Group](https://t.me/Apify_Actor) · 📧 [Support](https://t.me/AiAgentApi)

# Actor input Schema

## `country` (type: `string`):

Country where the target real estate listings are located

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

City, region, neighborhood, postal code, or address to search

## `max_results` (type: `integer`):

Maximum number of real estate listings to return per platform

## `listing_type` (type: `string`):

Listing status to search: for sale, for rent, or sold where supported

## `property_type` (type: `string`):

Optional property type filter. Leave empty to include all supported property types

## Actor input object example

```json
{
  "country": "United States",
  "location": "Denver, CO",
  "max_results": 10,
  "listing_type": "for_sale"
}
```

# Actor output Schema

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

All property listings found across platforms with structured listing details and source URLs.

# 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 = {
    "country": "United States",
    "location": "Denver, CO",
    "max_results": 10,
    "listing_type": "for_sale",
    "property_type": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("truefetch/zillow-real-estate-listings").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 = {
    "country": "United States",
    "location": "Denver, CO",
    "max_results": 10,
    "listing_type": "for_sale",
    "property_type": "",
}

# Run the Actor and wait for it to finish
run = client.actor("truefetch/zillow-real-estate-listings").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 '{
  "country": "United States",
  "location": "Denver, CO",
  "max_results": 10,
  "listing_type": "for_sale",
  "property_type": ""
}' |
apify call truefetch/zillow-real-estate-listings --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Zillow Real Estate Listings",
        "description": "Search Zillow real estate listings by city, ZIP, state, or address. Collect sale, rent, and sold property data with prices, beds, baths, square footage, images, location details, and source URLs.",
        "version": "1.0",
        "x-build-id": "zg1PLSgJecYJ42jt2"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/truefetch~zillow-real-estate-listings/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-truefetch-zillow-real-estate-listings",
                "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/truefetch~zillow-real-estate-listings/runs": {
            "post": {
                "operationId": "runs-sync-truefetch-zillow-real-estate-listings",
                "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/truefetch~zillow-real-estate-listings/run-sync": {
            "post": {
                "operationId": "run-sync-truefetch-zillow-real-estate-listings",
                "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": [
                    "country",
                    "location",
                    "max_results"
                ],
                "properties": {
                    "country": {
                        "title": "Country",
                        "enum": [
                            "Canada",
                            "United States"
                        ],
                        "type": "string",
                        "description": "Country where the target real estate listings are located"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City, region, neighborhood, postal code, or address to search"
                    },
                    "max_results": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of real estate listings to return per platform"
                    },
                    "listing_type": {
                        "title": "Listing Type",
                        "enum": [
                            "for_sale",
                            "for_rent",
                            "sold"
                        ],
                        "type": "string",
                        "description": "Listing status to search: for sale, for rent, or sold where supported"
                    },
                    "property_type": {
                        "title": "Property Type",
                        "enum": [
                            "residential",
                            "house",
                            "apartment",
                            "condo",
                            "townhouse",
                            "land",
                            "commercial",
                            "new_development",
                            "room",
                            "student_housing",
                            "senior_housing",
                            "auction",
                            "ready_to_build",
                            "other"
                        ],
                        "type": "string",
                        "description": "Optional property type filter. Leave empty to include all supported property types"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
