# Zillow API (`truefetch/zillow-api`) Actor

Search Zillow sale, rental, and sold listings across the United States and Canada. Collect 40 normalized property fields covering prices, beds, baths, area, images, location details, agent data, and source URLs.

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

## Pricing

from $12.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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 them, TrueFetch may receive a commission at no extra cost to you.

**Zillow Real Estate Listings is a focused Zillow property data Actor for exporting normalized sale, rental, and sold listing records from supported locations in the United States and Canada.**

- **Two country markets** are exposed by the current input schema: the United States and Canada.
- **Six public inputs** control country, location, result count, transaction type, property type, and listing age.
- **Forty normalized Dataset fields** cover pricing, rooms, area, address, images, dates, contacts, and source provenance.
- **The older public Store snapshot checked on 2026-07-21** showed 31 total users, 6 monthly active users, 3 bookmarks, and one 5.0 rating; it is historical public proof, not evidence of current code behavior.

[**Run a one-result test**](https://console.apify.com/actors/bdFppjxrVjQpbiLmo/input) · [**View API**](https://apify.com/truefetch/zillow-real-estate-listings/api?fpr=aiagentapi)

At the current FREE-tier prices in local metadata, a run that starts and stores one result costs at most **$0.02400**: $0.01000 for Actor Start plus $0.01400 for one Result. Matching inventory and field availability depend on Zillow at run time.

### What does Zillow Real Estate Listings do?

Zillow Real Estate Listings accepts a country, location, and result limit, searches the supported Zillow market, and returns property records in a stable 40-field Dataset. It supports the Actor's verified `for_sale`, `for_rent`, and `sold` transaction modes. The normalized result can contain price information, bedrooms and bathrooms, floor and land area, location and coordinates, listing dates, images, features, contact details, and the Zillow source URL.

This Actor is an independent data collection tool and is not affiliated with or endorsed by Zillow. It does not provide a licensed MLS feed, a Zestimate or appraisal service, title information, transaction authority, or professional real estate advice. Users must review Zillow's current Terms of Use at `https://www.zillow.com/corporate/terms-of-use/` and confirm that their intended access, retention, and use are permitted. Zillow's terms updated 2025-10-28 include restrictions on automated queries; using this Actor does not grant additional data rights.

### How do I run Zillow Real Estate Listings?

1. Open the [Actor input page](https://console.apify.com/actors/bdFppjxrVjQpbiLmo/input).
2. Select `United States` or `Canada`, then enter a location Zillow can interpret, such as a city, neighborhood, postal code, or address.
3. Set `max_results` from 1 to 10,000. For a safe first check, use 1.
4. Optionally select the transaction type, property type, or posted-date filter. Leave optional inputs empty when they are not needed.
5. Start the Actor, review the run status, and export the default Dataset.

All examples use one Denver house-for-sale scenario:

```json
{
  "country": "United States",
  "location": "Denver, CO",
  "max_results": 1,
  "listing_type": "for_sale",
  "property_type": "house",
  "posted_since": "7 days"
}
```

This input requests no more than one matching Zillow listing. It can return an empty Dataset if no current result satisfies the location and filters.

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

The Actor's effective Dataset schema defines 40 fields. Zillow does not expose every attribute on every listing, so unavailable values are returned as `null` instead of being inferred.

| Field group | Fields | What the group represents |
| --- | --- | --- |
| Listing presentation | `cover_image`, `image_urls`, `title`, `description` | Primary visual, image collection, headline, and cleaned listing text. |
| Identity and status | `listing_id`, `mls_id`, `listing_type`, `availability`, `market_type` | Zillow identifiers, transaction type, and source status context. |
| Classification | `property_type`, `subtype`, `category`, `business_type` | Normalized and source-specific property classifications. |
| Money and measurements | `price`, `rooms`, `area`, `land` | Nested price, bedroom/bathroom, interior area, and lot information. |
| Geography | `location`, `address`, `geo`, `country` | Display location, address, latitude/longitude, region, city, and postal code. |
| Building and timing | `building`, `dates`, `posted_time`, `fees` | Building characteristics, listing dates, market days, and available fee data. |
| Media and attributes | `media`, `open_houses`, `features`, `amenities`, `details` | Tours, floor plans, open-house times, features, amenities, and structured details. |
| Community context | `reviews`, `policies`, `units`, `nearby` | Ratings, policies, unit information, schools, transit, and nearby amenities when exposed. |
| Contact and source | `contact`, `platform`, `source_url`, `official_url` | Agent or agency data, source label, Zillow URL, and any explicit official outbound URL. |
| Processing record | `processor`, `processed_at` | Actor reference and UTC processing timestamp. |

An abbreviated illustrative item for the Denver scenario can look like this:

```json
{
  "cover_image": "https://images.example.com/denver-house.jpg",
  "title": "Three-bedroom house in Denver",
  "listing_id": "987654321",
  "listing_type": "for_sale",
  "property_type": "House",
  "price": {"value": 575000, "text": "$575,000", "currency": "USD"},
  "rooms": {"beds": 3, "baths": 2},
  "area": {"floor": 1680, "floor_unit": "sqft"},
  "location": "Denver, CO",
  "geo": {"lat": 39.7392, "lng": -104.9903, "city": "Denver"},
  "platform": "zillow",
  "source_url": "https://www.zillow.com/homedetails/987654321",
  "processor": "https://apify.com/truefetch/zillow-real-estate-listings",
  "processed_at": "2026-07-21T12:00:00+00:00"
}
```

The URLs, identifier, price, and property are examples for schema clarity, not a live Zillow listing.

### What inputs can I configure?

| Input | Type | Required | Verified behavior |
| --- | --- | --- | --- |
| `country` | string | Yes | Accepts `Canada` or `United States`. |
| `location` | string | Yes | Accepts a Zillow-supported city, region, neighborhood, postal code, or address. |
| `max_results` | integer | Yes | Returns at most 1–10,000 Zillow records for the run. |
| `listing_type` | string | No | Accepts `for_sale`, `for_rent`, or `sold`; omission uses `for_sale`. |
| `property_type` | string | No | Narrows results to a supported residential or land category. |
| `posted_since` | date/relative string | No | Requests listings within a date or relative period when Zillow supports that filter. |

Property-type compatibility also depends on transaction mode. `for_sale` supports `residential`, `house`, `apartment`, `condo`, `townhouse`, `land`, `new_development`, and `auction`. `for_rent` and `sold` support `residential`, `house`, `apartment`, `condo`, and `townhouse`. An incompatible combination is rejected or produces no selected source rather than being silently changed.

### What platforms and markets does Zillow Real Estate Listings cover?

This Actor is intentionally single-platform: it searches Zillow only. The input schema and current route map expose the United States and Canada. Location semantics remain Zillow-dependent, and country availability does not mean every city, property type, transaction mode, or historical record is present.

Zillow Research uses distinct vocabulary for market aggregates such as the Zillow Home Value Index and Zillow Observed Rent Index. This Actor does not return those research indices; it returns listing-level records from the supported search surface. For aggregate market series, consult Zillow Research at `https://www.zillow.com/research/data/` under its applicable terms. For listing records, retain `country`, `platform`, and `source_url` so downstream users can distinguish the source and verify context.

### Why use Zillow Real Estate Listings?

| Capability verified from the current Actor | Benefit for a data workflow |
| --- | --- |
| Zillow-only scope | Keep a focused source-specific run instead of searching unrelated marketplaces. |
| Sale, rental, and sold modes | Use one public schema for several Zillow transaction contexts. |
| Optional posted-date filtering | Build a recent-listing check when Zillow supports the requested window. |
| Forty normalized fields | Store identity, price, space, media, contact, and provenance in a predictable model. |
| Nullable source-aware output | Avoid fabricated values when Zillow does not expose an attribute. |

The trade-off is that a narrow source is easier to reason about but cannot provide independent marketplace corroboration. Use source URLs for verification and consider a multi-source Actor when comparisons across marketplaces are part of the research question.

### Who is Zillow Real Estate Listings for?

The Actor fits developers and analysts building authorized property research, inventory review, lead qualification, location monitoring, or internal data enrichment. A brokerage analyst might sample recent sale listings for a Denver review queue; a product team might inspect how bedrooms, price, area, and coordinates arrive in one Dataset; a researcher might build a source-linked set of current listings for manual verification.

The Actor is not appropriate for users seeking permission to republish Zillow content, a complete MLS database, regulated appraisal evidence, a substitute for licensed professional advice, or any use prohibited by Zillow or applicable law. The user remains responsible for lawful access, data minimization, retention, and downstream use.

### How can I use Zillow Real Estate Listings through the API or MCP?

The public Actor slug is `truefetch/zillow-real-estate-listings`, and the current Store console resolves it to Actor ID `bdFppjxrVjQpbiLmo`. Use the [official Actor API page](https://apify.com/truefetch/zillow-real-estate-listings/api?fpr=aiagentapi) for generated SDK and OpenAPI examples.

Run the same Denver scenario synchronously with HTTP:

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

Apify's current MCP page selects the Actor by slug through the hosted server:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=truefetch/zillow-real-estate-listings",
      "headers": {"Authorization": "Bearer <APIFY_TOKEN>"}
    }
  }
}
```

After connecting, invoke the selected Actor with the same Denver JSON input. Keep the token secret and use a one-result test before raising limits.

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

The current local metadata declares two billed events. Verify the [live pricing tab](https://apify.com/truefetch/zillow-real-estate-listings/pricing?fpr=aiagentapi) because Store prices can change.

| Event | FREE | BRONZE | SILVER | GOLD | PLATINUM | DIAMOND | Unit |
| --- | ---: | ---: | ---: | ---: | ---: | ---: | --- |
| Actor Start | $0.01000 | $0.01000 | $0.01000 | $0.01000 | $0.01000 | $0.01000 | One event when the Actor starts. |
| Result | $0.01400 | $0.01353 | $0.01307 | $0.01260 | $0.01260 | $0.01260 | One listing stored in the default Dataset. |

At the FREE tier, one stored result costs $0.01000 + (1 × $0.01400) = **$0.02400**. If the run stores no result, it incurs the start event but no Result event. Raising `max_results` increases the possible number of billed Result events.

### How does Zillow Real Estate Listings compare with alternatives?

| Option | Use it when | Important trade-off |
| --- | --- | --- |
| Zillow Real Estate Listings | Zillow is the intended source and a normalized export is needed | Single-source coverage and source-dependent nulls. |
| Global Real Estate Listings | The same location should be checked across compatible marketplaces | A broader run can return more results and cost more. |
| Manual Zillow browsing | A person needs to inspect a few listings under permitted use | Repetition and structured export are limited. |
| Licensed MLS or commercial feed | Contractual rights, defined completeness, or service levels are required | Separate licensing, fees, and data models apply. |
| Zillow Research datasets | Aggregate indices and published market series are the goal | These are not listing-level results from this Actor. |

Choose based on rights and research scope first. A convenient normalized schema does not replace source permission or a licensed data agreement.

### What are the limits and troubleshooting steps?

| Symptom or limit | Explanation and next step |
| --- | --- |
| The Dataset is empty | Try `max_results: 1` with fewer optional filters and a broad city or postal-code location. |
| The input is rejected | Confirm the country, integer result limit, transaction value, and property type match the public schema. |
| A property-type combination fails | Use the transaction-specific compatibility listed above or omit `property_type`. |
| Fields are `null` | Zillow did not expose those attributes for the listing. Keep fields nullable and verify the source page. |
| A sold or rental search differs from sale results | Each transaction mode has different inventory and supported property types. Do not compare counts as equivalent populations. |
| A source page changes after collection | Listing data is time-sensitive. Preserve `processed_at` and recheck `source_url` before relying on a value. |

For a reproducible support request, provide the run URL, sanitized input, expected behavior, and one relevant source URL. Never include an API token or private personal data. Public Store and review numbers cited above are an older deployment snapshot and must not be used to infer the state of the current local implementation.

### Frequently asked questions

#### Does the Actor support both the United States and Canada?

Yes. Those are the two countries in the effective input schema and route map.

#### Can I search rentals and sold homes as well as homes for sale?

Yes. Use `for_rent`, `sold`, or `for_sale`. Available inventory and compatible property types differ by mode.

#### What happens when I omit `listing_type`?

The current input validation uses `for_sale`. No other optional filter is invented when omitted.

#### Can I request new developments or auctions?

Yes for `for_sale`. Those property types are not accepted for the current rental or sold compatibility sets.

#### Does `posted_since` guarantee that every result was posted in the period?

No. It requests Zillow's supported date filtering; source behavior and listing timestamps remain authoritative.

#### Are Zestimate values guaranteed in every result?

No. The public Dataset has a flexible nested price object, but availability depends on the source listing. This Actor is not a Zestimate API.

#### Can the same property appear more than once over time?

Yes. Listings can change or be relisted. Use `listing_id`, `source_url`, transaction context, and processing time in downstream deduplication.

#### May I republish the returned images or descriptions?

The Actor does not grant those rights. Review Zillow's terms and obtain any permission required for your use.

### Related TrueFetch Actors

- [Global Real Estate Listings](https://apify.com/truefetch/global-real-estate-listings?fpr=aiagentapi) — use it when the research needs compatible non-Zillow marketplaces in the same normalized model.
- [Realtor Real Estate Listings](https://apify.com/truefetch/realtor-real-estate-listings?fpr=aiagentapi) — use it for a focused Realtor.com workflow in the United States.
- [Redfin Real Estate Listings](https://apify.com/truefetch/redfin-real-estate-listings?fpr=aiagentapi) — use it for a separate Redfin sale-listing source in the United States or Canada.

### Support and last updated

This README was verified on **2026-07-21** against the effective local schemas, read-only runtime evidence, current Apify API/MCP pages, Zillow's official research vocabulary, and Zillow's terms updated 2025-10-28. The [Store page](https://apify.com/truefetch/zillow-real-estate-listings?fpr=aiagentapi), [API page](https://apify.com/truefetch/zillow-real-estate-listings/api?fpr=aiagentapi), [pricing tab](https://apify.com/truefetch/zillow-real-estate-listings/pricing?fpr=aiagentapi), and [Issues page](https://apify.com/truefetch/zillow-real-estate-listings/issues/open?fpr=aiagentapi) are the formal Actor links. Online Store content is treated as an older deployed snapshot, not as current code truth.

For help, contact the [TrueFetch community](https://t.me/TrueFetch) or [direct support](https://t.me/AiAgentApi) with a sanitized one-result reproduction.

[**Run a controlled one-result check**](https://console.apify.com/actors/bdFppjxrVjQpbiLmo/input) · [**Review the API options**](https://apify.com/truefetch/zillow-real-estate-listings/api?fpr=aiagentapi)

# Actor input Schema

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

Country where Zillow listings will be searched

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

City, region, neighborhood, postal code, or address supported by Zillow

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

Maximum number of Zillow property listings to return

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

Choose the transaction status to search

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

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

## `posted_since` (type: `string`):

Only include listings posted within this timeframe when Zillow supports posted-date filtering

## Actor input object example

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

# Actor output Schema

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

Overview table for the default dataset of normalized property listings.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "country": "United States",
    "location": "Denver, CO",
    "max_results": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("truefetch/zillow-api").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,
}

# Run the Actor and wait for it to finish
run = client.actor("truefetch/zillow-api").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
}' |
apify call truefetch/zillow-api --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/bdFppjxrVjQpbiLmo/builds/ieKJCvLtCR6T72VuS/openapi.json