# Zillow Map Results (`alol/zillow-map-results`) Actor

Collect lightweight Zillow map cards beyond one result window with automatic area subdivision. Build deduplicated map feeds with your own result limit and visible collection limits.

- **URL**: https://apify.com/alol/zillow-map-results.md
- **Developed by:** [Al Ol](https://apify.com/alol) (community)
- **Stats:** 2 total users, 1 monthly users, 94.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.15 / 1,000 map results — usd 2.00 to usd 1.15 per 1,000s

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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Zillow Map Scraper: Property Coordinates and ZPIDs

**Scrape Zillow map results with property coordinates, prices, and ZPIDs for geographic analysis and property discovery.** Search by ZIP code, location, Zillow URL, or map bounds. Automatic subdivision explores dense areas, while deduplication combines overlapping targets into one output.

- **Discover properties hidden inside grouped map pins:** building cards are expanded into individual properties with their own ZPIDs, coordinates, and prices, then deduplicated against ordinary map results.
- **Choose your own scale:** `maxResults` has no fixed upper bound in the input schema; set a positive limit of at least 20. The default is 20. Source availability, subdivision depth, run time, and budgets still apply; collecting every property is not guaranteed.
- **Build map and inventory feeds:** retrieve available coordinates, prices, and core property facts without requesting a full detail record for every home.
- **Make coverage visible:** output quality metadata reports collection limits and missing data, so downstream analysis can account for incomplete results.

Zillow Map Results returns lightweight, normalized property cards sourced from Zillow’s `mapResults` response and individual properties resolved from grouped building cards. It is intended for map inventories, geographic analysis, bulk ZPID discovery, and workflows that do not need the richer `listResults` card fields.

The Actor writes one Dataset row per unique map result. For richer `listResults` cards, use [Zillow Search](https://apify.com/alol/zillow-search). For detailed data from property pages, including available agent and broker attribution, use [Zillow Property Details](https://apify.com/alol/zillow-property-details). For ongoing change tracking with saved monitor state, use [Zillow Listing Monitor](https://apify.com/alol/zillow-listing-monitor). Standalone professional profiles are not supported by our current Actors.

### Use cases

- Collect dense map inventories with coordinates and stable Zillow property IDs.
- Build lightweight geographic datasets for visualization or downstream enrichment.
- Discover properties across ZIP codes, free-text regions, Zillow search URLs, or custom bounds.
- Reduce the public output surface when rich search-card metadata is unnecessary.

### Automatic building expansion

Zillow sometimes combines several properties into one building card (`isBuilding=true`). This Actor opens the building’s exposed unit inventory, retrieves the actual property records for matching candidates, and merges them into collection by ZPID. A property appearing both individually and inside a group is counted once. There is no extra input switch.

Search status, price, bedroom, bathroom, size, property-type, and map-bound filters are checked against individual properties. Sold and off-market units are not added to an active-sale search. Existing result limits and budgets still apply; expanding buildings requires additional source requests and may increase run time.

Zillow may return `null`, empty lists, or omit optional unit lists. These values are skipped while available individual properties are still processed; missing inventory alone does not degrade the scan or trigger retries. Floor-plan IDs and building minimum prices are never substituted for individual property records. Actual fetch failures, unfinished pagination, and invalid property data still affect collection quality.

### Input examples

At least one of `zipCodes`, `locationQueries`, `searchUrls`, or `mapBounds` must identify a search area.

#### ZIP search

```json
{
  "zipCodes": [
    "78704"
  ],
  "maxResults": 100
}
```

#### Filtered map search

```json
{
  "locationQueries": [
    "Austin, TX"
  ],
  "listingTypes": [
    "forSale",
    "fsbo"
  ],
  "priceMin": 300000,
  "priceMax": 900000,
  "bedsMin": 3,
  "bathsMin": 2,
  "sqftMin": 1500,
  "sqftMax": 3000,
  "homeTypes": [
    "house",
    "townhome"
  ],
  "daysOnZillowMax": 30,
  "keywords": [
    "garage"
  ],
  "maxResults": 500
}
```

#### Map-bounds search

```json
{
  "mapBounds": {
    "north": 30.35,
    "south": 30.2,
    "east": -97.65,
    "west": -97.85
  },
  "listingTypes": [
    "forRent"
  ],
  "externalId": "austin-map",
  "correlationId": "sync-2026-09-01",
  "maxConcurrency": 10
}
```

#### Search within a radius and sale-date window

Use `center` with `radiusMiles` for an exact circular target. A fractional radius such as 2.5 miles is supported. Do not combine it with ZIP codes, location queries, search URLs or map bounds. Cards without coordinates are excluded. Sale-date boundaries are inclusive; unknown sale dates are excluded. Date windows require only the sold listing type and cannot be combined with `daysOnZillowMax` or search URLs.

```json
{
  "center": {
    "latitude": 47.6,
    "longitude": -122.3
  },
  "radiusMiles": 2.5,
  "listingTypes": [
    "sold"
  ],
  "soldDateFrom": "2026-08-01",
  "soldDateTo": "2026-09-11",
  "maxResults": 20
}
```

The source is queried over an enclosing rectangle; exact radius and sale-date filters run before the result limit. A narrow window may still require many source requests. Use upstream attempt/cost limits to bound that work; reaching them can leave the result incomplete.

### Output examples

#### Map-result row

```json
{
  "externalId": "austin-map",
  "correlationId": "sync-2026-09-01",
  "zpid": "123456789",
  "url": "https://www.zillow.com/homedetails/123456789_zpid/",
  "address": {
    "full": "100 Example Ave, Austin, TX 78704"
  },
  "latitude": 30.25,
  "longitude": -97.75,
  "status": "FOR_SALE",
  "price": 625000,
  "currency": "USD",
  "zestimate": 618000,
  "rentZestimate": 3200,
  "beds": 3,
  "baths": 2,
  "livingAreaSqft": 1840,
  "lotAreaSqft": 6534,
  "homeType": "SINGLE_FAMILY",
  "lastModifiedAt": "2026-08-29T15:30:00.000Z",
  "scrapedAt": "2026-09-01T10:00:00.000Z",
  "quality": {
    "expected": null,
    "fetched": 1,
    "deduplicated": 1,
    "emitted": 1,
    "coverage": null,
    "truncated": false,
    "degraded": false,
    "dataAgeSeconds": null,
    "completeness": "unknown",
    "reasons": [
      "runLevelCoverageUnavailablePerRow",
      "sourceDataAgeUnavailable"
    ]
  }
}
```

#### Construction year, sale data and price basis

`yearBuilt`, `lastSoldPrice`, `lastSoldDate` and `pricePerSqft` are nullable. Ordinary search cards usually do not include construction year; an expanded building unit may provide it. No per-card Details request is added to fill these fields. Older stored cards may omit them.

`lastSoldDate` is the source's calendar sale date, not the listing or modification date. `lastSoldPrice` uses an exact disclosed numeric price on a confirmed sold card; it stays null when absent or conflicting. Rounded display labels such as "$1.28M" do not replace an exact numeric sale price. Some markets do not disclose sale prices.

`pricePerSqft` divides a known numeric card price by positive living area: asking price for active sale listings, monthly rent for rentals, disclosed transaction price for sold cards. These bases are different; do not mix them in a single market median. Unavailable or ambiguous values remain null.

### Pricing

**Max Cost:** the Actor limits collection to the number of listings the remaining run budget can pay for. It stops new pages, subdivisions, and targets when that limit is reached, then finishes the pending output. Saved Dataset rows and their charges are retained; the requested result count may not be reached.

There is no fixed start charge. Platform usage is included in paid result events. Paid runs request at least 20 results, and each successfully written map-result row is charged as one `search-result` event.

The effective result price depends on the customer's Apify tier. Apify applies the rate for the customer's eligible account tier to every charged map-result row:

| Apify tier | Per map-result row | Per 1,000 rows |
| --- | ---: | ---: |
| FREE | `$0.00200` | `$2.00` |
| BRONZE | `$0.00170` | `$1.70` |
| SILVER | `$0.00145` | `$1.45` |
| GOLD | `$0.00115` | `$1.15` |

Prices may change; the Apify Console shows the effective tier and price before a run.

The input minimum of 20 requests a result limit; it is not a minimum bill. If only three cards are published, three result events apply. A platform minimum spending limit is the smallest permitted cap, not a fixed fee.

### FAQ

#### Can I collect Zillow property coordinates for a map?

Yes. Map cards include available latitude, longitude, price, and ZPID values. Use them for geographic datasets or pass selected ZPIDs to [Zillow Property Details](https://apify.com/alol/zillow-property-details) for enrichment. Coordinate availability depends on the source.

#### Does this Actor return Zillow's raw JSON?

No. Its search requests use `mapResults`; grouped cards trigger additional building and property requests. Both paths return the same compact normalized schema without raw Zillow payloads.

#### Why can the Dataset be empty?

No listing may match, filters may remove every card, or an upstream target may be unavailable. A zero-row Dataset is valid.

#### How is this different from Zillow Search?

[Zillow Search](https://apify.com/alol/zillow-search) requests richer `listResults` cards. This Actor starts from `mapResults`, which favors dense map coverage and a narrower schema. Both Actors can expand grouped buildings into individual properties.

### Related Actors

Explore our other real-estate Actors for property discovery, enrichment, market analysis, and monitoring:

- [Zillow Search](https://apify.com/alol/zillow-search) — Collect listing cards by ZIP code, location, search URL, or map bounds.
- [Zillow Area Statistic](https://apify.com/alol/zillow-area-statistic) — Get ZIP-level statistics calculated from Zillow sale or rental listings.
- [Zillow Property Details](https://apify.com/alol/zillow-property-details) — Enrich Zillow property IDs or detail URLs with detailed property records.
- [Zillow Listing Monitor](https://apify.com/alol/zillow-listing-monitor) — Track new listings, price changes, status changes, and confirmed delistings across repeated scans.
- [Realtor.com Listings by ZIP](https://apify.com/alol/realtor-search) — Collect Realtor.com listing cards and separate market-statistics rows by ZIP code.
- [Realtor.com ZIP Market Stats](https://apify.com/alol/realtor-zip-statistics) — Get Realtor.com housing-market aggregates by ZIP code without collecting listing cards.
- [Realtor.com Property Details](https://apify.com/alol/realtor-property-details) — Enrich Realtor.com property IDs or detail URLs with detailed property records.

### Responsible use and data availability

Use the Actor only where your collection and downstream processing comply with applicable law, contractual terms, privacy obligations, and platform rules. Zillow controls upstream availability and fields can be missing, delayed, or changed.

# Actor input Schema

## `externalId` (type: `string`):

Optional caller-owned run ID copied to every output row.

## `correlationId` (type: `string`):

Optional trace/workflow ID copied to every output row.

## `zipCodes` (type: `array`):

One or more US ZIP codes to search.

## `locationQueries` (type: `array`):

Free-text locations, e.g. 'Austin, TX' or 'Travis County, TX'. Resolved via Zillow autocomplete.

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

Paste ready-made Zillow search-result URLs. Their filters are honored as-is.

## `mapBounds` (type: `object`):

Bounding box { north, south, east, west } in decimal degrees. Adds a target alongside any ZIP, location-query, or URL targets.

## `center` (type: `object`):

Center of a circular Search / Map Results target. Supply radiusMiles; do not combine with other targets.

## `radiusMiles` (type: `number`):

Exact radius, including fractional values such as 2.5. Requires center. Missing coordinates are excluded.

## `soldDateFrom` (type: `string`):

Inclusive YYYY-MM-DD sale date. Requires only the sold listing type; excludes unknown dates. Cannot combine with searchUrls or daysOnZillowMax.

## `soldDateTo` (type: `string`):

Inclusive YYYY-MM-DD sale date. Requires only the sold listing type; excludes unknown dates.

## `listingTypes` (type: `array`):

Which listing categories to include.

## `priceMin` (type: `number`):

Lowest listing price to include, in USD.

## `priceMax` (type: `number`):

Highest listing price to include, in USD.

## `bedsMin` (type: `number`):

Minimum number of bedrooms.

## `bathsMin` (type: `number`):

Minimum number of bathrooms.

## `sqftMin` (type: `number`):

Minimum living area in square feet.

## `sqftMax` (type: `number`):

Maximum living area in square feet.

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

Restrict to specific property types. Empty = all.

## `daysOnZillowMax` (type: `number`):

Only listings from Zillow's supported age window. Allowed values: 1, 7, 14, 30, 90, 180, or 365 days.

## `keywords` (type: `array`):

Free-text keyword filter, e.g. 'pool', 'waterfront'.

## `updatedSince` (type: `string`):

Search only. Return listings whose Zillow lastModifiedAt is at or after this ISO-8601 timestamp.

## `updatedSinceUnknownPolicy` (type: `string`):

Search only. Zillow does not expose lastModifiedAt for every card. Include preserves recall; exclude gives a strict incremental feed.

## `maxResults` (type: `integer`):

Maximum emitted rows across all targets. Paid runs require at least 20 requested results.

## `maxTotalChargeUsd` (type: `number`):

Hard limit for pay-per-event charges in this run. The Actor stops writing paid results before the limit is exceeded.

## `maxUpstreamAttempts` (type: `integer`):

Optional run-level ceiling for Zillow, Apify Proxy, and Scraping Browser attempts. The operator deployment limit can only reduce this value.

## `maxUpstreamCostUsd` (type: `number`):

Optional best-effort ceiling for all measured upstream proxy and Scraping Browser costs, including search tiers and the detail Apify fallback. The final request may cause a small overshoot.

## `maxConcurrency` (type: `integer`):

Maximum parallel requests.

## Actor input object example

```json
{
  "zipCodes": [
    "10314"
  ],
  "listingTypes": [
    "forSale"
  ],
  "homeTypes": [],
  "updatedSinceUnknownPolicy": "include",
  "maxResults": 20,
  "maxConcurrency": 10
}
```

# Actor output Schema

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

No description

# 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 = {
    "zipCodes": [
        "10314"
    ],
    "listingTypes": [
        "forSale"
    ],
    "maxResults": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("alol/zillow-map-results").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 = {
    "zipCodes": ["10314"],
    "listingTypes": ["forSale"],
    "maxResults": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("alol/zillow-map-results").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 '{
  "zipCodes": [
    "10314"
  ],
  "listingTypes": [
    "forSale"
  ],
  "maxResults": 20
}' |
apify call alol/zillow-map-results --silent --output-dataset

```

## MCP server setup

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

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/PFLtrxmvKIoPzLlRx/builds/3SE6wh1G7sap2tx13/openapi.json