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

Zillow real estate listings API for United States and Canada searches. Return 40 normalized fields by location without requiring a separate Zillow API credential.

- **URL**: https://apify.com/truefetch/zillow-api.md
- **Developed by:** [TrueFetch](https://apify.com/truefetch) (community)
- **Categories:** Real estate, Developer tools, Integrations
- **Stats:** 51 total users, 4 monthly users, 100.0% runs succeeded, 5 bookmarks
- **User rating**: 4.02 out of 5 stars

## Pricing

from $10.50 / 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/actors/running/actors-in-store.md#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

**Zillow API is a zillow real estate listings api that searches Zillow by location and returns 40 normalized, source-linked property fields for developers building housing research and monitoring pipelines.**

- **40 public Dataset fields** cover listing identity, classification, price, dimensions, location, media, contacts, provenance, and processing time.
- **7 public inputs with four required fields** make country, location, transaction, and result limits explicit.
- **the United States and Canada coverage** follows the verified fixed-route or country-routing map instead of claiming universal availability.
- **Pay-per-event billing** is $0.01000 per Actor Start plus $0.01400 for each Result stored on the FREE tier.

[**Run a one-result test**](https://console.apify.com/actors/bdFppjxrVjQpbiLmo/input) · [**View API**](https://apify.com/truefetch/zillow-api/api)

Set `max_results` to `1` for the smallest useful test; if one listing is stored, the FREE-tier maximum is **$0.02400**, while a no-result search still incurs Actor Start.

### What does Zillow API do?

Zillow API converts one explicit property search into source-attributed rows that share a stable 40-field Dataset shape. It resolves the requested location, applies only supported filters, collects accepted public advertisements, and normalizes their source values for API, MCP, and export workflows.

One record can include listing IDs, transaction and property classifications, nested price and room data, areas, address and coordinates, images, features, dates, agent or agency details, the source platform, and a URL back to the advertisement. Missing details remain empty; the Actor does not estimate a price, infer a person, or fill a field from a different listing.

This is an independent public-listing search interface. It is not an MLS feed, valuation model, due-diligence service, official partner API, or guarantee that every source exposes the same inventory. [Zillow](https://www.zillow.com/news/zillows-new-tool-powers-home-searches-in-up-to-five-areas-at-once-letting-shoppers-move-as-fast-as-the-market/) is the official source reference used here: Zillow's official product announcement documents location-based search across neighborhoods, ZIP codes, cities, counties, and states, with map and result-feed views.

### How do I run Zillow API?

Run Zillow API by providing `max_results`, `country`, `location`, and `listing_type`, then start with a one-result request.

1. Open the [Actor input](https://console.apify.com/actors/bdFppjxrVjQpbiLmo/input).
2. Use the working Toronto, ON scenario and reduce `max_results` to `1`.
3. Leave optional fields empty unless this edition documents that the source route supports them.
4. Start the run and inspect the terminal returned-property count.
5. Open the default Dataset and verify `platform`, `location`, `price`, and `source_url` before scaling.

```json
{
  "max_results": 1,
  "country": "Canada",
  "location": "Toronto, ON",
  "listing_type": "for_sale"
}
```

`max_results` is a ceiling on accepted rows, not a guaranteed count. A valid run can return zero rows when no public listing matches, the place cannot be resolved, or a supplied filter is incompatible with the route.

### What data does Zillow API return?

Zillow API returns one normalized Dataset row for each accepted property advertisement, using exactly 40 top-level fields.

| Group | Fields |
| --- | --- |
| Identity, media, and classification | `cover_image, image_urls, title, description, listing_id, mls_id, listing_type, availability, market_type, property_type, subtype, category, business_type` |
| Price and size | `price, rooms, area, land` |
| Place and timing | `location, address, geo, country, building, dates, posted_time` |
| Listing detail | `fees, media, open_houses, features, amenities, details, reviews, policies, units, nearby` |
| Contact and provenance | `contact, platform, source_url, official_url` |
| Processing | `processor, processed_at` |

The following JSON is abbreviated and illustrative; a real result follows the full 40-field schema and can contain additional nested values or nulls:

```json
{
  "title": "Illustrative Toronto, ON property listing",
  "listing_id": "source-12345",
  "listing_type": "for_sale",
  "property_type": "apartment",
  "price": {
    "value": 750000,
    "text": "750,000",
    "currency": "CAD"
  },
  "rooms": {
    "beds": 2,
    "baths": 2
  },
  "location": "Toronto, ON",
  "country": "Canada",
  "platform": "zillow",
  "source_url": "https://example.com/property/source-12345",
  "processed_at": "2026-08-10T12:00:00.000Z"
}
```

`source_url` is the primary verification path, while `platform`, `processor`, and `processed_at` preserve provenance. JSON keeps nested objects intact; CSV and Excel are convenient for review; the Dataset API supports downstream jobs that need paginated items.

### What inputs can I configure?

Zillow API exposes 7 public inputs in the shared family order. `max_results`, `country`, `location`, and `listing_type` are required in every edition; `property_type`, `posted_since`, and `platforms` remain present and optional even when a fixed route requires them to be left empty.

| Parameter | Type | Required | Description | Example |
| --- | --- | --- | --- | --- |
| `max_results` | integer | Yes | Maximum number of property listings to return from Zillow | `3` |
| `country` | string (2 schema options) | Yes | Markets supported by the fixed Zillow route: Canada and United States. | `Canada` |
| `location` | string | Yes | City, region, neighborhood, postal code, or address to search on Zillow | `Toronto` |
| `listing_type` | string (3 schema options) | Yes | Transaction types supported by Zillow: for\_sale, for\_rent, and sold. | `for_sale` |
| `property_type` | string (8 schema options) | No | Optional Zillow property-type filter: residential, house, apartment, condo, townhouse, land, new\_development, and auction. Leave empty for no property-type restriction. | `optional` |
| `posted_since` | string | No | Optional listing-age filter supported by the fixed Zillow route. Accepts YYYY-MM-DD or a relative value such as 7 days. | `optional` |
| `platforms` | array (1 schema option) | No | Compatibility selector retained across every property-family edition. This edition always uses Zillow; leave empty or select Zillow. | `optional` |

The effective console prefill is:

```json
{
  "max_results": 3,
  "country": "Canada",
  "location": "Toronto",
  "listing_type": "for_sale"
}
```

The `platforms` field is intentionally retained with the singleton schema value `Zillow`. Runtime identity fixes this edition to Zillow; the field is not deleted merely to differentiate the product.

`property_type` and `posted_since` affect requests only when explicitly supplied with a value supported by this route.

### What platforms and markets does Zillow API cover?

Zillow API covers Zillow in the United States and Canada, subject to the source map and the transaction modes documented for this edition.

- **Platform:** Zillow.
- **Markets:** the United States and Canada. The fixed Zillow route accepts United States and Canada locations.
- **Transactions:** for\_sale, for\_rent, and sold.
- **Property type:** residential, house, apartment, condo, townhouse, land, new\_development, and auction.
- **Posted date:** supported by the Zillow route.
- **Output language:** source text is preserved where available; schema keys remain stable English identifiers.

Coverage describes the route the Actor can request, not a promise that every neighborhood has current inventory. Source ranking, advertiser participation, field population, and listing freshness remain external conditions.

### Why use Zillow API?

Use Zillow API when a stable, source-linked API row is more useful than repeating a manual search or maintaining a source-specific parser.

| Capability | Practical benefit |
| --- | --- |
| 40-field normalized Dataset | Build one validation and export layer for identity, price, location, media, contacts, and provenance. |
| Explicit country and location | Make the requested market reviewable in logs and saved inputs. |
| Bounded `max_results` | Start with one row and increase collection only after inspecting quality. |
| Result-event billing | Relate output cost to rows actually stored in the default Dataset. |
| API and MCP access | Reuse the same Actor ID in code, agents, Make.com, n8n, or scheduled workflows. |

The main trade-off is source dependence. This read-only public-listing interface does not provide an official Zillow partnership, MLS license, or guaranteed inventory completeness. The normalized envelope reduces integration work, but it cannot manufacture unavailable fields or contractual data rights.

### Who is Zillow API for?

Zillow API is for developers, property-data teams, market researchers, and operations analysts who can work with nullable, source-attributed public advertisements.

- **Data engineers** can land JSON rows in a warehouse and validate source coverage before expanding a schedule.
- **Market analysts** can compare visible prices, rooms, area, and location for Toronto, ON without treating the sample as the whole market.
- **Product teams** can prototype source-linked search experiences while keeping verification URLs in the record.
- **Operations teams** can create a bounded review queue from `max_results`, `listing_type`, and explicit location inputs.
- **Quality teams** can measure field fill rates and source changes against the named 40-field contract.

The reverse persona is equally important: Choose an authorized MLS or data feed for licensed redistribution, guaranteed availability, or contractual data quality. Do not use this Actor as the sole basis for housing eligibility, lending, valuation, investment, legal, or safety decisions.

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

Call Zillow API with real Actor ID `bdFppjxrVjQpbiLmo` or the name form `truefetch/zillow-api`; both refer to this public Actor.

```bash
curl -X POST "https://api.apify.com/v2/acts/bdFppjxrVjQpbiLmo/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"max_results": 1, "country": "Canada", "location": "Toronto, ON", "listing_type": "for_sale"}'
```

For MCP, connect the official Apify MCP server, select Actor `bdFppjxrVjQpbiLmo`, and submit the same one-result JSON input. Name `max_results`, `country`, `location`, and `listing_type` in the tool call rather than referring to a distant example. After completion, read the run's default Dataset and retain `source_url` for review.

The [live API page](https://apify.com/truefetch/zillow-api/api) provides generated SDK and OpenAPI examples. In Make.com or n8n, use `bdFppjxrVjQpbiLmo` in the run step, wait for a terminal run state, then fetch items with `defaultDatasetId`.

### How much does Zillow API cost?

Zillow API costs $0.01400 per Result on the FREE tier, and the smallest one-result test costs at most $0.02400 including the $0.01000 Actor Start.

| Plan tier | Price per Result |
| --- | ---: |
| FREE | $0.01400 |
| BRONZE | $0.01260 |
| SILVER | $0.01120 |
| GOLD | $0.01050 |
| PLATINUM | $0.01050 |
| DIAMOND | $0.01050 |

The billing unit is one property listing stored in the default Dataset. The exact smallest calculation is **$0.01000 Actor Start + 1 × $0.01400 Result = $0.02400**. A valid search with no stored rows still pays Actor Start but has no Result event.

Prices can change, so confirm the [live pricing page](https://apify.com/truefetch/zillow-api/pricing) before scheduling or increasing `max_results`.

### How does Zillow API compare with alternatives?

Zillow API is best when a bounded API request and normalized source-linked rows are the priority; other paths fit different rights and reliability needs.

- **Manual browsing** is efficient for a handful of listings that one person will inspect immediately, but not for repeated structured comparison.
- **The source's own website** is best for interactive maps, saved searches, alerts, and consumer browsing. [Zillow](https://www.zillow.com/news/zillows-new-tool-powers-home-searches-in-up-to-five-areas-at-once-letting-shoppers-move-as-fast-as-the-market/) is the official source reference used here: Zillow's official product announcement documents location-based search across neighborhoods, ZIP codes, cities, counties, and states, with map and result-feed views.
- **Separate official integrations** are better when authenticated features, licensed redistribution, complete inventory, or service levels are mandatory.
- **Valuation and analytics services** are better for modeled prices, forecasts, or due-diligence outputs; this Actor returns advertisements, not an appraisal.

This read-only public-listing interface does not provide an official Zillow partnership, MLS license, or guaranteed inventory completeness. Choose another path if nulls are unacceptable, the use requires a license this Actor cannot grant, or a source outage must never interrupt the workflow.

### What are the limits and troubleshooting steps?

The main limits are source-dependent inventory, filter compatibility, location resolution, nullable fields, and public-page availability.

- **Zero rows → no match or unresolved location →** rerun `Toronto, ON` with `max_results=1`, verify the country and spelling, and remove one optional filter at a time.
- **Filter is skipped → route lacks that capability →** follow this edition's schema-supported listing, property-type, and posted-date choices.
- **Fewer rows than requested → accepted inventory ended first →** treat `max_results` as a ceiling and inspect the run log.
- **Null values → source did not expose reliable detail →** keep null-safe downstream types and verify important facts at `source_url`.
- **Intermittent failure → source response or controls changed →** retry the smallest scenario once, then report a reproducible run instead of repeatedly increasing retries.

Open the [Issues page](https://apify.com/truefetch/zillow-api/issues) with the run ID, sanitized one-result input, expected behavior, actual behavior, and UTC timestamp. Never post an API token, private permission document, or personal data in a public issue.

### Frequently asked questions

Zillow API answers the most common questions about credentials, location inputs, nullable fields, schedules, result ceilings, and billing.

#### How do I use a zillow listings api without an official api key?

Use `bdFppjxrVjQpbiLmo` with the one-result JSON input and an Apify token; no separate source credential is an input to this Actor. This describes the Actor's interface, not permission or an official partnership with the source.

#### Can I get zillow property data by location?

Yes. Set the supported country, enter a source-valid location, choose a supported listing type, and keep `max_results=1` until the returned `platform`, `location`, and `source_url` are correct.

#### Is there a free real estate listings API?

There is no zero-cost promise in this Actor's pricing. Apify account credits may cover testing, but the FREE pricing tier still defines a $0.01000 Actor Start and $0.01400 per stored Result.

#### Can I schedule runs to monitor property listings over time?

Yes. Use Apify Schedules with the same explicit input and compare `listing_id`, `price`, `availability`, and `processed_at` across Datasets. The Actor does not maintain history or send change alerts by itself.

#### Why do some fields remain null?

The source advertisement may omit them or a detail page may be unavailable. The 40-field schema is stable, but populated values vary by source, advertiser, market, and listing type.

#### Does `max_results` guarantee the requested count?

No. It limits accepted output; it does not create matching inventory. Zero or partial results can be correct outcomes for a narrowly filtered or unavailable search.

#### Is Zillow API an official Zillow API?

No. It is an independent TrueFetch Actor that normalizes public listing search data. It does not provide affiliation, endorsement, partner credentials, licensed feed rights, or permission for a particular reuse.

### Related TrueFetch Actors

These three TrueFetch Actors are the closest alternatives to Zillow API, each for a distinct source or coverage decision.

- [Real Estate Listings API](https://apify.com/truefetch/real-estate-listings-api) — narrows the workflow to its source-specific search contract.
- [Realtor Listings API](https://apify.com/truefetch/realtor-listings-api) — covers an adjacent market with the same 40-field Dataset shape.
- [Redfin API](https://apify.com/truefetch/redfin-api) — provides the closest alternative route for cross-source comparison.

### Support

Get product details from the [Store page](https://apify.com/truefetch/zillow-api), generated endpoints from the [API page](https://apify.com/truefetch/zillow-api/api), and current prices from the [pricing page](https://apify.com/truefetch/zillow-api/pricing). Report reproducible defects on the [Issues page](https://apify.com/truefetch/zillow-api/issues) with a sanitized input and run ID; ask general questions in the [TrueFetch community](https://t.me/TrueFetch).

[**Run a bounded one-result search**](https://console.apify.com/actors/bdFppjxrVjQpbiLmo/input) · [**Review the API contract**](https://apify.com/truefetch/zillow-api/api)

**Last Updated:** August 10, 2026

# Actor input Schema

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

Maximum number of property listings to return from Zillow

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

Markets supported by the fixed Zillow route: Canada and United States.

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

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

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

Transaction types supported by Zillow: for\_sale, for\_rent, and sold.

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

Optional Zillow property-type filter: residential, house, apartment, condo, townhouse, land, new\_development, and auction. Leave empty for no property-type restriction.

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

Optional listing-age filter supported by the fixed Zillow route. Accepts YYYY-MM-DD or a relative value such as 7 days.

## `platforms` (type: `array`):

Compatibility selector retained across every property-family edition. This edition always uses Zillow; leave empty or select Zillow.

## Actor input object example

```json
{
  "max_results": 12,
  "country": "Canada",
  "location": "Toronto",
  "listing_type": "for_sale"
}
```

# 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 = {
    "max_results": 12,
    "country": "Canada",
    "location": "Toronto",
    "listing_type": "for_sale"
};

// 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 = {
    "max_results": 12,
    "country": "Canada",
    "location": "Toronto",
    "listing_type": "for_sale",
}

# 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(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "max_results": 12,
  "country": "Canada",
  "location": "Toronto",
  "listing_type": "for_sale"
}' |
apify call truefetch/zillow-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,truefetch/zillow-api"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

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