# Zillow Property Scraper with Agents & Description (`fatihtahta/zillow-property-scraper`) Actor

Extract Zillow property listings at scale with prices, full descriptions, photo galleries, coordinates, property facts, amenities, and agent contacts. Built for market research, comps, inventory monitoring, CRM enrichment, BI, and ETL pipelines.

- **URL**: https://apify.com/fatihtahta/zillow-property-scraper.md
- **Developed by:** [Fatih Tahta](https://apify.com/fatihtahta) (community)
- **Categories:** Real estate, Automation, Agents
- **Stats:** 2 total users, 1 monthly users, 75.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / 1,000 property listings

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

## Zillow Property Scraper

**Slug:** `fatihtahta/zillow-property-scraper`

### Overview

Zillow Property Scraper collects structured public property listing records from [Zillow](https://www.zillow.com/). It supports location-based searches, direct Zillow search or listing URLs, and common real estate filters such as listing mode, price, bedrooms, bathrooms, property type, status, amenities, views, parking, area, building year, keywords, and listing freshness. Each saved record is normalized into a grouped property listing object with source provenance, listing identity, pricing, location, property facts, media, metrics, availability, contact details, relationships, and source-specific attributes when available. The actor is designed for market research, comparable-listing review, recurring monitoring, CRM enrichment, BI dashboards, ETL pipelines, and AI-agent workflows. It can also write run-level summary and map artifacts so users can verify counts, coverage, coordinates, and export readiness without inspecting every record manually. Optional MCP connector delivery can send a compact run summary and output links to user-authorized Apify connector destinations when configured. Results reflect publicly available Zillow data at run time and should be verified before legal, financial, valuation, brokerage, or operational decisions.

### What Makes This Actor Different

- **Schema-led output:** records use a stable `property_listing` envelope with grouped objects for pricing, location, property facts, media, availability, contacts, relationships, and attributes.
- **Flexible starting points:** use a location, a direct Zillow search URL, a map/list URL, or specific listing URLs.
- **Real estate filters:** narrow runs by listing mode, sort order, price, payment, beds, baths, property type, listing category, status, tours, HOA, parking, area, lot size, year built, amenities, views, keywords, and freshness.
- **Coverage-aware option:** `maximize_coverage` can collect deeper within the selected criteria when first visible results are not enough.
- **Enrichment control:** `enrich_data` lets users choose richer listing details or faster search-level validation runs.
- **Run receipts:** the actor can write `RUN-SUMMARY`, `RUN-SUMMARY.html`, and `results-map` artifacts for review, audit, and downstream routing.
- **Pipeline-friendly identity:** `record_id`, `listing.listing_id`, `property.property_id`, and `url` make recurring upserts and deduplication easier.
- **Connector-ready delivery:** `mcpConnectors` can deliver compact run summaries and output links through user-authorized Apify MCP connectors when selected.

### Who Should Use This Actor

- Real estate analysts comparing asking prices, inventory, status, location, and property mix across markets.
- Brokerage, investment, and operations teams monitoring Zillow listing changes over time.
- CRM and lead operations teams enriching internal records with public listing facts and source links.
- Data engineers building real estate ingestion, normalization, warehouse, or search-index pipelines.
- BI teams creating dashboards for public listing inventory, pricing bands, geography, amenities, and availability.
- AI-agent builders that need structured property listing records and run receipts for automated workflows.
- Product, research, and marketplace teams that need repeatable public property-data collection.

### Common Use Cases

- Track new or recently updated public Zillow listings in a city, ZIP code, neighborhood, or market.
- Build comparable-listing datasets by property type, price band, bedroom count, bathroom count, and listing status.
- Monitor price-reduced listings, open houses, tours, or specific amenities.
- Review rental, sale, or sold-listing history based on the selected `deal_type`.
- Enrich internal property, lead, or account records with public listing URLs, pricing, location, and property facts.
- Export structured records into BI tools, spreadsheets, data warehouses, CRMs, or AI workflows.
- Compare repeated runs using stable listing identifiers and point-in-time pricing or status fields.
- Use map artifacts to review coordinate coverage and geographic distribution for saved listings.

### Real-World Questions This Data Can Answer

- Which public listings match a specific city, price band, property type, and bedroom/bathroom profile?
- How many saved listings include coordinates, open-house signals, photos, contact details, or enrichment data?
- Which listings appear to be price reduced, recently posted, pending, coming soon, or active?
- What is the distribution of saved listings by city, region, status, property type, or deal type?
- Which records should be upserted, deduplicated, or compared across repeated monitoring runs?
- Which listings have enough structured detail for CRM review, BI reporting, alerts, or AI-agent analysis?
- Did a run stop at the requested limit, and did coverage-aware collection produce deeper matching results?

### Quick Start

1. Open `fatihtahta/zillow-property-scraper` in Apify Console.
2. Enter a `location` or paste one or more direct Zillow URLs in `url`.
3. Choose `deal_type` and any filters needed for your target market or listing segment.
4. Set `limit` to a small value for the first validation run.
5. Start the actor and inspect the first dataset records.
6. Review `RUN-SUMMARY`, `RUN-SUMMARY.html`, and `results-map` when they are available.

### Input Parameters

| Field | Type | Default | Options | Description |
| --- | --- | --- | --- | --- |
| `url` | array | none | Zillow search, map/list, or listing URLs | Direct Zillow URLs to collect from. Use one URL per item for repeatable known searches or specific listings. |
| `location` | string | none | any Zillow-supported city, state, ZIP, neighborhood, or market | Location used to build a Zillow search when URLs are not provided. |
| `deal_type` | single select | `buy` | `buy`, `rent`, `sold` | Listing mode for structured searches. |
| `sort_by` | single select | `globalrelevanceex` | `globalrelevanceex`, `days`, `priced`, `pricea`, `paymentd`, `paymenta`, `beds`, `baths`, `size`, `lot`, `zest`, `zesta` | Sort order requested from Zillow before collection. |
| `min_price` | integer | none | numeric amount | Minimum asking price or rent. |
| `max_price` | integer | none | numeric amount | Maximum asking price or rent. |
| `min_monthly_payment` | integer | none | numeric amount | Minimum estimated monthly payment. |
| `max_monthly_payment` | integer | none | numeric amount | Maximum estimated monthly payment. |
| `bedroom_count` | multi select | none | `1`, `2`, `3`, `4`, `5` | Bedroom threshold requested from Zillow. |
| `bathroom_count` | multi select | none | `1`, `2`, `3`, `4`, `5` | Bathroom threshold requested from Zillow. |
| `property_type` | multi select | none | `houses`, `condos_coops`, `apartments_condos_coops`, `multi_family`, `apartments`, `manufactured`, `lots_land`, `townhomes`, `room`, `entire_place` | Property categories to include. Leave empty for all supported categories in scope. |
| `max_hoa` | single select | none | `0`, `50`, `100`, `200`, `300`, `400`, `500`, `600`, `700`, `800`, `900`, `1000`, `1500`, `2000` | Maximum monthly HOA fee. |
| `listing_type` | multi select | none | `agent_listed`, `owner_posted`, `new_construction`, `foreclosures`, `auctions`, `foreclosed`, `pre_foreclosures` | Listing source and ownership categories. |
| `listing_status` | multi select | none | `active`, `coming_soon`, `zillow_preview`, `pending_under_contract`, `accepting_backup_offers` | Listing status groups to include. |
| `tours` | multi select | none | `open_house`, `3d_tour`, `showcase` | Tour, open-house, or showcase signals to require. |
| `min_parking` | single select | none | `1+`, `2+`, `3+`, `4+` | Minimum parking capacity. |
| `closed_garage` | boolean | `false` | `true`, `false` | Require garage parking. |
| `min_floor_area` | integer | none | square feet | Minimum interior floor area. |
| `max_floor_area` | integer | none | square feet | Maximum interior floor area. |
| `min_land_area` | integer | none | square feet | Minimum lot or land area. |
| `max_land_area` | integer | none | square feet | Maximum lot or land area. |
| `min_building_year` | integer | none | four-digit year | Earliest building year. |
| `max_building_year` | integer | none | four-digit year | Latest building year. |
| `basement` | boolean | `false` | `true`, `false` | Require basement mentions. |
| `single_story` | boolean | `false` | `true`, `false` | Require single-story listings. |
| `55_plus_communities` | single select | none | `include`, `exclude`, `only` | Include, exclude, or require 55+ community listings. |
| `amenities` | multi select | none | `air_conditioning`, `pool`, `waterfront`, `disabled_access`, `hardwood_floors`, `utilities_included`, `fitness_center`, `dishwasher`, `high_speed_internet`, `elevator`, `furnished`, `outdoor_space`, `pets_allowed`, `in_unit_laundry`, `short_term_lease`, `controlled_access`, `no_pets`, `promotion` | Amenities or rental features to require. |
| `view` | multi select | none | `city`, `mountain`, `park`, `water` | View types to require. |
| `commute_time` | string | none | destination text | Commute destination for Zillow-supported commute filtering. |
| `price_reduced` | boolean | `false` | `true`, `false` | Only include listings marked as price reduced. |
| `publication_date` | single select | none | `any`, `1`, `7`, `14`, `30`, `90`, `6m`, `12m`, `24m`, `36m` | Listing freshness window. |
| `keyword` | string | none | text | Keyword or phrase to search in listing text. |
| `maximize_coverage` | boolean | `false` | `true`, `false` | Collect deeper within the selected criteria when broad searches have more matching listings than the first visible result set. |
| `enrich_data` | boolean | `true` | `true`, `false` | Collect richer listing details when available. Disable for faster validation when search-result fields are enough. |
| `mcpConnectors` | array | `[]` | user-authorized Apify MCP connectors | Optional connector destinations for compact run-summary delivery with dataset, summary, and map links when available. |
| `limit` | integer | none | positive integer | Maximum number of listing records to save. |

### Choosing Inputs

Use `location` when you want the actor to build a Zillow search from a market, listing mode, and filters. Use `url` when you already have a Zillow search page, map/list page, or listing URL that you want to monitor repeatedly. Choose `deal_type` first because sale, rental, and sold-listing workflows usually require different filters and downstream interpretation. Add price, payment, bedrooms, bathrooms, property type, status, listing type, area, year, parking, tour, view, amenity, keyword, and freshness filters only when they are part of your intended scope. Leave optional filters empty for broad discovery or early validation. Split large workflows by city, neighborhood, property type, price band, listing mode, or status when you need cleaner downstream comparison. Enable `maximize_coverage` when deeper collection inside the same selected criteria is more important than the fastest exploratory run. Disable `enrich_data` for quick shape checks when the first visible result set and standard fields are enough.

### Input Recipes

- **Validation run:** choose one focused `location`, keep filters minimal, set a small `limit`, and optionally disable `enrich_data` to inspect the output shape quickly.
- **Targeted property search:** combine `location`, `deal_type`, `property_type`, `min_price`, `max_price`, `bedroom_count`, and `bathroom_count` for a comparable listing slice.
- **Broad market discovery:** use `location`, `deal_type`, `sort_by`, a sensible `limit`, and few optional filters to understand available inventory.
- **Maximum matching coverage:** enable `maximize_coverage` with a broad market, selected property criteria, and an explicit `limit` when deeper matching collection matters.
- **Monitoring run:** reuse the same `location` or `url`, set `publication_date` or `sort_by`, and schedule the actor to compare new, repriced, updated, or removed listings.
- **Enrichment run:** paste known Zillow listing URLs in `url`, keep `enrich_data` enabled, and use a moderate `limit` to collect richer listing details for review or matching.

### Example Inputs

#### Location-driven sale search

```json
{
  "location": "Austin, TX",
  "deal_type": "buy",
  "property_type": ["houses", "townhomes"],
  "min_price": 450000,
  "max_price": 900000,
  "bedroom_count": ["3"],
  "limit": 25
}
````

#### Recently listed rental monitoring

```json
{
  "location": "Brooklyn, NY",
  "deal_type": "rent",
  "sort_by": "days",
  "publication_date": "7",
  "amenities": ["in_unit_laundry", "pets_allowed"],
  "limit": 50
}
```

#### Direct listing URL enrichment

```json
{
  "url": [
    "https://www.zillow.com/homedetails/8144-Irondale-Ave-Winnetka-CA-91306/19908910_zpid/"
  ],
  "deal_type": "buy",
  "enrich_data": true,
  "limit": 1
}
```

### Output

#### Output Destination

The actor writes results to an Apify dataset as JSON records. The dataset is designed for direct consumption by analytics tools, ETL pipelines, AI agents, and downstream APIs with minimal post-processing.

The current dataset contract exposes one record shape: `property_listing`. Each record represents one public Zillow listing and is documented below based on the dataset schema, saved rows, and run-artifact evidence.

#### Record Envelope And Stable Identifiers

Each record includes required top-level fields: `record_type`, `record_id`, `url`, `source_context`, `entity`, and `listing`. The recommended idempotency key is `record_id`, with `listing.listing_id`, `property.property_id`, `entity.external_ids.zpid`, and `url` as useful reconciliation fields. Use the same key for deduplication and upserts when syncing repeated runs into warehouses, CRMs, search indexes, vector stores, or monitoring systems. Stable identifiers make records easier to merge, deduplicate, sync, and compare across recurring runs. Provenance fields such as `source_context.source_url`, `source_context.canonical_url`, `source_context.seed_url`, `source_context.search_query`, `source_context.scraped_at`, and `source_context.fingerprint` help trace the public source and compare snapshots.

#### Example: Property Listing Record

```json
{
  "record_type": "property_listing",
  "record_id": "123456789",
  "url": "https://www.zillow.com/homedetails/123-Sample-Oak-Ave-Austin-TX-78701/123456789_zpid/",
  "source_context": {
    "source_id": "zillow_property_scraper",
    "source_domain": "zillow.com",
    "source_url": "https://www.zillow.com/homedetails/123-Sample-Oak-Ave-Austin-TX-78701/123456789_zpid/",
    "canonical_url": "https://www.zillow.com/homedetails/123-Sample-Oak-Ave-Austin-TX-78701/123456789_zpid/",
    "seed_url": "https://www.zillow.com/austin-tx/",
    "search_query": "Austin TX homes",
    "seed_type": "zillow_search",
    "seed_value": "Austin TX homes",
    "page_number": 1,
    "position": 3,
    "deal_type": "buy",
    "enrichment_status": "enriched",
    "enrichment_requested": true,
    "scraped_at": "2026-07-09T17:32:14+00:00",
    "country": "US",
    "fingerprint": "sample-record-fingerprint",
    "search": {
      "url": "https://www.zillow.com/austin-tx/",
      "deal_type": "buy",
      "source_list": "listResults"
    }
  },
  "entity": {
    "title": "123 Sample Oak Ave, Austin, TX 78701",
    "description": "Sample public listing description for a renovated home near parks and transit.",
    "url": "https://www.zillow.com/homedetails/123-Sample-Oak-Ave-Austin-TX-78701/123456789_zpid/",
    "status": "House for sale",
    "external_ids": {
      "zpid": "123456789"
    }
  },
  "listing": {
    "listing_id": "123456789",
    "listing_type": "property_listing",
    "listing_status": "FOR_SALE",
    "deal_type": "sale",
    "transaction_type": "House for sale",
    "posted_at": "1771772735000"
  },
  "pricing": {
    "price": 725000,
    "price_text": "$725,000",
    "currency": "USD",
    "price_per_area": 402.78,
    "source_price_per_square_foot": 403,
    "estimates": {
      "zestimate": 731000,
      "rent_zestimate": 3850,
      "estimated_monthly_cost": 4680
    },
    "price_changes": {
      "last_change_amount": -15000,
      "last_change_date": "2026-07-07"
    },
    "fees": {
      "monthly_hoa_fee": 125
    },
    "valuation": {
      "tax_assessed_value": 610000
    }
  },
  "location": {
    "address": "123 Sample Oak Ave, Austin, TX 78701",
    "city": "Austin",
    "region": "TX",
    "postal_code": "78701",
    "country": "US",
    "latitude": 30.2672,
    "longitude": -97.7431
  },
  "property": {
    "property_id": "123456789",
    "property_type": "SINGLE_FAMILY",
    "bedrooms": 3,
    "bathrooms": 2.5,
    "floor_area": 1800,
    "land_area": 6500,
    "area_unit": "sqft",
    "land_area_unit": "sqft",
    "lot_size_text": "6500 sqft",
    "year_built": 2014,
    "parking_capacity": 2,
    "garage_parking_capacity": 2,
    "parking_features": ["Driveway", "Garage"]
  },
  "media": {
    "main_image_url": "https://photos.zillowstatic.com/fp/sample-photo-p_e.jpg",
    "image_urls": [
      "https://photos.zillowstatic.com/fp/sample-photo-p_e.jpg"
    ],
    "photos": [
      {
        "url": "https://photos.zillowstatic.com/fp/sample-photo-p_e.jpg",
        "key": "sample-photo",
        "source": "search_carousel"
      }
    ],
    "photo_count": 32,
    "virtual_tours": [
      {
        "type": "third_party",
        "url": "https://www.example.com/sample-tour",
        "approved": true
      }
    ]
  },
  "metrics": {
    "view_count": 276,
    "save_count": 14,
    "days_on_zillow": 6,
    "time_on_zillow": "6 days",
    "time_on_zillow_ms": 518400000
  },
  "availability": {
    "open_house": {
      "description": "Open House - 2:00 - 4:00 PM",
      "starts_at": "2026-07-11T14:00:00",
      "ends_at": "2026-07-11T16:00:00"
    },
    "tour_eligibility": {
      "self_tour": false,
      "contact_agent": true
    },
    "date_posted": "1771772735000"
  },
  "contact_details": {
    "phones": ["555-0100"],
    "emails": ["agent@example.com"],
    "contacts": [
      {
        "name": "Sample Agent",
        "phone": "555-0100",
        "email": "agent@example.com",
        "role": "listing_agent"
      }
    ]
  },
  "relationships": {
    "agent": {
      "name": "Sample Agent",
      "mls_id": "SAMPLE123",
      "mls_name": "Sample MLS"
    },
    "agency": {
      "name": "Example Realty Group",
      "mls_id": "SAMPLE456",
      "mls_name": "Sample MLS"
    }
  },
  "attributes": {
    "flags": {
      "has_image": true,
      "has_video": false,
      "has_open_house": true,
      "is_showcase": false,
      "is_zillow_owned": false
    },
    "zillow": {
      "ids": {
        "zpid": "123456789",
        "result_id": "123456789"
      },
      "status": {
        "status_type": "FOR_SALE",
        "status_text": "House for sale",
        "marketing_status": "For Sale by Agent"
      },
      "display": {
        "content_type": "daysOnZillow",
        "flex_field_text": "6 days on Zillow"
      },
      "search_result": {
        "source_list": "listResults",
        "is_list_result": true,
        "is_relaxed_match": false
      },
      "listing_sub_type": {
        "is_FSBA": true,
        "is_FSBO": false,
        "is_openHouse": true
      },
      "enrichment": {
        "detail_available": true
      }
    }
  }
}
```

#### Run Summary, Map, And Artifacts

The actor can write stable Apify key-value-store artifacts after dataset records are saved:

| Artifact | Key | Purpose |
| --- | --- | --- |
| Run summary JSON | `RUN-SUMMARY` | Machine-readable run receipt with saved listing counts, selected input scope, filter summary, enrichment coverage, location coverage, coordinate coverage, top records, and artifact keys. |
| Run summary HTML | `RUN-SUMMARY.html` | Human-readable report for reviewing listing totals, coverage, enrichment, pricing, property facts, location breakdowns, media coverage, and representative records. |
| Interactive listing map | `results-map` | Standalone map for saved records with valid latitude and longitude values. If no valid coordinates are available, the map reports zero mapped listings. |
| Run summary diagnostics | `RUN-SUMMARY-ERROR` | Best-effort public diagnostic written only if run summary generation fails after records were saved. |

Use these artifacts as a run receipt before importing data into production dashboards, CRMs, warehouses, alerting systems, or agent workflows. They can help verify completion, saved listing count, skipped or duplicate outcomes, selected coverage mode, limit behavior, enrichment count, coordinate coverage, map marker count, and export readiness. When `maximize_coverage` is enabled, the run summary helps confirm that deeper matching collection was requested, how many listings were saved, and whether the requested `limit` shaped the final output.

### Field Reference

#### Record Envelope

- **record\_type** *(string, required)*: dataset row family; Zillow listing rows use `property_listing`.
- **record\_id** *(string, required)*: stable Zillow listing identifier and recommended upsert key.
- **url** *(string, required)*: primary public Zillow listing URL.

#### source\_context

- **source\_context.source\_id** *(string, optional)*: source identifier for the listing record.
- **source\_context.source\_domain** *(string, optional)*: source website domain, usually `zillow.com`.
- **source\_context.source\_url** *(string, optional)*: public source URL used as the listing audit link.
- **source\_context.canonical\_url** *(string, optional)*: canonical listing URL when available.
- **source\_context.seed\_url** *(string, optional)*: input search, map/list, or listing URL that led to the record.
- **source\_context.search\_query** *(string, optional)*: human-readable query or market used for search-mode runs.
- **source\_context.seed\_type** *(string, optional)*: seed family, such as a Zillow search or direct listing URL.
- **source\_context.seed\_value** *(string, optional)*: normalized seed value for grouping and audit review.
- **source\_context.page\_number** *(integer, optional)*: result page number when available.
- **source\_context.position** *(integer, optional)*: listing position within the result set when available.
- **source\_context.deal\_type** *(string, optional)*: requested mode such as `buy`, `rent`, or `sold`.
- **source\_context.enrichment\_status** *(string, optional)*: whether the record is search-level or enriched with richer details.
- **source\_context.enrichment\_requested** *(boolean, optional)*: whether richer detail collection was requested.
- **source\_context.enrichment\_source** *(string, optional)*: source family for richer detail fields when available.
- **source\_context.scraped\_at** *(string, optional)*: collection timestamp.
- **source\_context.language** *(string, optional)*: language or locale when available.
- **source\_context.country** *(string, optional)*: country code associated with the source context.
- **source\_context.fingerprint** *(string, optional)*: record fingerprint useful for recurring snapshot comparison.
- **source\_context.search** *(object, optional)*: search-specific context such as URL, deal type, and source-list metadata.

#### entity

- **entity.title** *(string, optional)*: display title, usually the address or listing headline.
- **entity.description** *(string, optional)*: listing description when richer detail collection is available.
- **entity.url** *(string, optional)*: public listing URL associated with the display entity.
- **entity.status** *(string, optional)*: Zillow display status or label.
- **entity.external\_ids.zpid** *(string, optional)*: Zillow property identifier.

#### listing

- **listing.listing\_id** *(string, optional)*: source listing identifier, normally matching `record_id`.
- **listing.listing\_type** *(string, optional)*: normalized listing family.
- **listing.listing\_status** *(string, optional)*: listing status code, such as active, pending, sold, or sale-related states.
- **listing.deal\_type** *(string, optional)*: normalized transaction family such as sale, rent, or sold.
- **listing.transaction\_type** *(string, optional)*: display transaction text.
- **listing.posted\_at** *(string, optional)*: source-provided posted timestamp or date string.

#### pricing

- **pricing.price** *(number, optional)*: numeric displayed asking price or rent.
- **pricing.price\_text** *(string, optional)*: human-readable displayed price.
- **pricing.currency** *(string, optional)*: currency code for numeric price fields.
- **pricing.price\_per\_area** *(number, optional)*: price per interior area unit when available.
- **pricing.source\_price\_per\_square\_foot** *(number, optional)*: Zillow-provided price per square foot when available.
- **pricing.estimates.zestimate** *(number, optional)*: Zillow-provided Zestimate when present.
- **pricing.estimates.rent\_zestimate** *(number, optional)*: Zillow-provided rent estimate when present.
- **pricing.estimates.estimated\_monthly\_cost** *(number, optional)*: Zillow-provided estimated monthly cost when present.
- **pricing.price\_changes.last\_change\_amount** *(number, optional)*: most recent price-change amount when available.
- **pricing.price\_changes.last\_change\_date** *(string, optional)*: date of the most recent price change when available.
- **pricing.fees.monthly\_hoa\_fee** *(number, optional)*: monthly HOA fee when exposed.
- **pricing.valuation.tax\_assessed\_value** *(number, optional)*: source-provided tax assessed value when exposed.

#### location

- **location.address** *(string, optional)*: displayed listing address or address-like label.
- **location.city** *(string, optional)*: city or locality.
- **location.region** *(string, optional)*: state, province, or region code.
- **location.postal\_code** *(string, optional)*: postal or ZIP code.
- **location.country** *(string, optional)*: country code.
- **location.latitude** *(number, optional)*: latitude for mapping and geospatial workflows when available.
- **location.longitude** *(number, optional)*: longitude for mapping and geospatial workflows when available.

#### property

- **property.property\_id** *(string, optional)*: source property identifier, normally matching the Zillow property ID.
- **property.property\_type** *(string, optional)*: source or normalized property type.
- **property.bedrooms** *(integer, optional)*: bedroom count.
- **property.bathrooms** *(number, optional)*: bathroom count; decimal values may appear.
- **property.floor\_area** *(number, optional)*: interior floor area.
- **property.land\_area** *(number, optional)*: lot or land area.
- **property.area\_unit** *(string, optional)*: unit for `floor_area`.
- **property.land\_area\_unit** *(string, optional)*: unit for `land_area`.
- **property.lot\_size\_text** *(string, optional)*: source-formatted lot size text.
- **property.year\_built** *(integer, optional)*: construction year.
- **property.parking\_capacity** *(number, optional)*: parking capacity.
- **property.garage\_parking\_capacity** *(number, optional)*: garage parking capacity.
- **property.parking\_features** *(array of strings, optional)*: parking feature labels.

#### media

- **media.main\_image\_url** *(string, optional)*: primary listing image URL.
- **media.image\_urls** *(array of strings, optional)*: gallery image URLs.
- **media.photos** *(array of objects, optional)*: photo records with URL, key, and optional source metadata.
- **media.photo\_count** *(integer, optional)*: source-provided or counted number of photos.
- **media.virtual\_tours** *(array of objects, optional)*: virtual-tour links and labels when exposed.

#### metrics

- **metrics.view\_count** *(integer, optional)*: source-provided view count.
- **metrics.save\_count** *(integer, optional)*: source-provided save count.
- **metrics.days\_on\_zillow** *(integer, optional)*: days-on-market style counter.
- **metrics.time\_on\_zillow** *(string, optional)*: display text for time on Zillow.
- **metrics.time\_on\_zillow\_ms** *(number, optional)*: time-on-Zillow value in milliseconds when available.

#### availability

- **availability.open\_house.description** *(string, optional)*: open-house display text.
- **availability.open\_house.starts\_at** *(string, optional)*: open-house start date or time when available.
- **availability.open\_house.ends\_at** *(string, optional)*: open-house end date or time when available.
- **availability.tour\_eligibility** *(object, optional)*: tour scheduling options and windows when exposed.
- **availability.date\_posted** *(string, optional)*: source-provided posting timestamp or date string.

#### contact\_details

- **contact\_details.phones** *(array of strings, optional)*: public phone numbers exposed with the listing.
- **contact\_details.emails** *(array of strings, optional)*: public email addresses exposed with the listing.
- **contact\_details.contacts** *(array of objects, optional)*: contact cards with name, phone, email, and role when available.

#### relationships

- **relationships.agent.name** *(string, optional)*: displayed listing agent name.
- **relationships.agent.mls\_id** *(string, optional)*: source-provided MLS identifier associated with the agent or listing when available.
- **relationships.agent.mls\_name** *(string, optional)*: source-provided MLS name when available.
- **relationships.agency.name** *(string, optional)*: displayed agency or brokerage name.
- **relationships.agency.mls\_id** *(string, optional)*: source-provided MLS identifier associated with the agency or listing when available.
- **relationships.agency.mls\_name** *(string, optional)*: source-provided MLS name when available.

#### attributes

- **attributes.flags** *(object, optional)*: boolean listing signals such as image, video, showcase, Zillow-owned, and open-house flags.
- **attributes.zillow.ids** *(object, optional)*: Zillow-specific identifiers such as zpid, result ID, pals ID, ssid, or MLS ID.
- **attributes.zillow.status** *(object, optional)*: Zillow-specific status codes and display status fields.
- **attributes.zillow.display** *(object, optional)*: display labels such as flex field text or content type.
- **attributes.zillow.search\_result** *(object, optional)*: search-result metadata such as source list and result flags.
- **attributes.zillow.listing\_sub\_type** *(object, optional)*: listing subtype flags such as FSBA, FSBO, foreclosure, auction, new home, open house, or pending.
- **attributes.zillow.enrichment** *(object, optional)*: additional source detail facts when richer listing data is available.

### Data Model Notes

- **Identity fields:** use `record_id` as the primary upsert key; keep `listing.listing_id`, `property.property_id`, `entity.external_ids.zpid`, and `url` for reconciliation.
- **Source provenance:** `source_context` fields trace each record back to its public source, input seed, search context, and collection timestamp.
- **Property and listing attributes:** `entity`, `listing`, `pricing`, `location`, `property`, `media`, `availability`, `contact_details`, and `relationships` carry the main review and analysis value.
- **Pricing and status fields:** prices, estimates, valuation-like values, statuses, availability, and descriptions are point-in-time public signals.
- **Nested objects:** related values stay grouped so JSON-first pipelines, APIs, and AI agents can preserve context.
- **Optional fields:** null-check fields that depend on listing type, region, account visibility, source availability, enrichment, or selected filters.
- **Repeated runs:** compare records by stable identifier plus Apify run metadata, input segment, and timestamp stored in your downstream system.

### Data Quality, Guarantees, And Handling

- **Structured records:** results are normalized into predictable JSON objects for downstream use.
- **Field preservation:** meaningful schema-supported listing and property values are kept in stable public fields or grouped objects when available.
- **Best-effort extraction:** fields may vary by region, availability, account visibility, listing type, UI experiments, or source-side changes.
- **Optional fields:** null-check optional fields in downstream code, dashboards, and agents.
- **Deduplication:** use `record_id` first, with `listing.listing_id`, `property.property_id`, `entity.external_ids.zpid`, and `url` as supporting keys.
- **Freshness:** results reflect publicly available Zillow data at run time.
- **Repeated runs:** use the recommended idempotency key when syncing data into warehouses, CRMs, search indexes, vector stores, or monitoring systems.
- **Schema awareness:** downstream systems should rely on documented fields and handle newly missing optional fields gracefully.
- **Run receipts:** use summary and map artifacts to audit listing counts, coverage mode, skipped outcomes, enrichment status, map readiness, and export readiness without treating artifacts as replacement dataset records.

### Tips For Best Results

- Start with a small `limit` to validate the output shape before scaling up.
- Use one city, neighborhood, ZIP code, property type, price band, listing mode, or status segment per run when you need clean comparison.
- Leave optional filters empty when the goal is broad market discovery.
- Add filters gradually to understand how each field changes coverage.
- Keep `enrich_data` enabled for richer listing review, and disable it for quick validation runs when search-level data is enough.
- Keep `maximize_coverage` enabled for broad matching searches when deeper collection matters more than speed.
- Schedule recurring runs for monitoring workflows instead of relying on manual one-off runs.
- Review run summary and map artifacts before importing records into production pipelines, dashboards, CRMs, or AI workflows.

### How to Run on Apify

1. Open the actor in Apify Console.
2. Configure the available input fields for the target location, URLs, or property scope.
3. Set `limit` to the maximum number of listings you want to save.
4. Click **Start** and wait for the run to finish.
5. Open the dataset and inspect the first records.
6. Download results in JSON, CSV, Excel, or another supported format.

### Agentic And API-First Usage

The actor can be used as a structured public property-data acquisition step inside larger automated workflows. It works well when an agent or pipeline needs a scoped Zillow input, normalized listing records, stable identifiers, and a compact run receipt for follow-up decisions.

1. Generate or select a scoped input from the supported schema.
2. Run the actor manually, on a schedule, or through Apify platform automation.
3. Wait for completion and read the dataset records.
4. Validate records against the field reference.
5. Read run summary or map artifacts when present to verify counts, coverage state, limit behavior, skipped outcomes, coordinates, and export readiness.
6. Upsert records into the downstream system using `record_id`.
7. Trigger market analysis, enrichment, alerts, BI refreshes, vector/search indexing, lead review, or human verification.

Practical notes for agentic use:

- Keep prompts and automations grounded in the documented input parameters.
- Start with small validation runs before allowing broad automated collection.
- Feed the Field Reference and a small output sample to downstream AI steps.
- Feed run summary or map artifacts to downstream agents when present so they can reason about completion, record counts, coverage, location distribution, and follow-up actions.
- Treat optional property and listing fields as nullable instead of asking agents to infer missing values.
- Store run ID, input configuration, and dataset export metadata outside the record when building audit trails.
- For tools such as Claude, Codex, internal copilots, or property workflow agents, pass the input schema, Field Reference, idempotency key, and one representative output example when context is limited.

### Scheduling & Automation

#### Scheduling

**Automated Data Collection**

Use Apify schedules to keep Zillow-derived listing datasets fresh for recurring market monitoring, alerting, CRM review, or reporting.

- Navigate to **Schedules** in Apify Console.
- Create a new schedule, such as daily, weekly, or a custom cron interval.
- Configure input parameters for the market, URLs, filters, and `limit`.
- Enable notifications for run completion.
- Add webhooks for automated processing.

#### Integration Options

- **CRM enrichment:** sync public listing, pricing, location, property, agency, or contact attributes into account, property, or lead records.
- **BI dashboards:** monitor asking prices, availability, listing status, property mix, geography, photos, and enrichment coverage over time.
- **Warehouses and ETL pipelines:** ingest normalized JSON records into analytics systems with stable upsert keys.
- **Google Sheets or Airtable:** review smaller market slices, lead lists, or validation outputs with operations teams.
- **Webhooks:** trigger validation, notifications, imports, or alerts after each completed run.
- **MCP connectors:** authorize a connector in Apify, select it in `mcpConnectors`, and use the delivered compact listing summary plus dataset, summary, or map links in the destination tool when available.
- **Search or vector indexes:** index listing titles, descriptions, locations, property facts, and source links for discovery or AI retrieval workflows.

### Export Formats And Downstream Use

- **JSON:** for APIs, applications, AI agents, and data pipelines that preserve nested objects.
- **CSV or Excel:** for spreadsheet workflows, stakeholder review, and lightweight analysis.
- **API access:** for automated ingestion into internal systems.
- **BI and warehouses:** for reporting, dashboards, historical analysis, and monitoring.
- **Search or vector indexes:** for discovery, semantic search, retrieval workflows, or agent context.

### Downstream Pipeline Guide

- **Idempotency:** use `record_id` for upserts, with URL and source IDs as supporting reconciliation fields.
- **Null handling:** treat optional fields as nullable, especially contact details, estimates, photos, tour data, open-house data, coordinates, MLS labels, and enriched facts.
- **Type handling:** preserve numbers, booleans, arrays, and nested objects when exporting to JSON-first systems.
- **Flattening:** if exporting to CSV or Excel, flatten nested objects deliberately and keep the original JSON export for full fidelity.
- **Partitioning:** store run date, input segment, geography, property type, listing mode, and workflow name outside or alongside records for easier analysis.
- **Change detection:** compare repeated runs by `record_id` and selected business fields such as `pricing.price`, `listing.listing_status`, `availability.date_posted`, `metrics.days_on_zillow`, or key property facts.
- **Quality checks:** monitor record count, duplicate rate, required identifiers, price/status availability, coordinate coverage, enrichment status, and important optional field fill rates.
- **Human review:** route records with missing critical fields, unusual values, changed status, price changes, or high-value segments into a review queue when needed.
- **Retention:** decide how long to keep raw exports versus normalized warehouse tables based on your use case.

### Performance And Coverage Expectations

Example run metrics from saved validation artifacts:

| Run type | Example scope | Listings | Duration | Coverage notes |
| --- | --- | --- | --- | --- |
| Location validation | Focused location, lightweight output | 1 | about 4 seconds | Passed dataset validation. |
| Direct URL validation | One Zillow URL, lightweight output | 1 | about 2 seconds | Passed dataset validation. |
| Enriched location validation | Focused location with enrichment enabled | 1 | about 4 seconds | Passed dataset validation. |
| Coverage validation | Broad collection with higher limit | 800 | about 65 seconds | Passed dataset validation with 800 saved records. |
| Artifact validation | Two saved listings with coordinates | 2 | not recorded | Wrote `RUN-SUMMARY`, `RUN-SUMMARY.html`, and `results-map`; map marker count was 2. |

These are example validation runs, not guarantees. Execution time varies based on filters, result volume, target availability, target response size, enrichment depth, coordinate and map artifact creation, and how much information is returned per listing. Highly filtered runs can finish faster, while broad discovery, `maximize_coverage`, enrichment, or detail-rich listing records may take longer. `maximize_coverage` prioritizes deeper retrieval within the selected criteria and can trade speed for a more complete matching collection.

### Limitations

- Availability depends on what Zillow publicly exposes at run time.
- Some optional fields may be missing on sparse records, certain property types, direct URL records, or listings without richer public detail.
- Very broad searches may take longer or require higher `limit` values.
- Coverage-aware runs can take longer when many listings match the selected criteria.
- Target-side changes can affect field availability, naming, or display values.
- Regional, account, visibility, listing status, and availability differences may change visible results.
- Listing prices, estimates, availability, status, descriptions, and valuation-like values are point-in-time public signals and should be verified before operational decisions.
- The actor provides structured public real estate data, not legal, financial, investment, valuation, appraisal, MLS, or brokerage advice.

### Troubleshooting

- **No results returned:** check filters, location spelling, listing mode, property category, direct URLs, and whether Zillow has matching public records.
- **Fewer results than expected:** broaden filters, raise `limit`, enable `maximize_coverage` for broad searches, or verify that Zillow contains enough matching records.
- **Some fields are empty:** optional fields depend on what each listing publicly provides and whether richer detail collection is available.
- **Duplicate-looking records:** compare `record_id`, `listing.listing_id`, `property.property_id`, and `url` to decide whether records represent variants, updates, or distinct listings.
- **Run takes longer than expected:** reduce scope, lower `limit` for validation, disable `enrich_data` for a quick shape check, or split broad collection into smaller segments.
- **Output changed:** compare the current output with the Field Reference and report a small sample if support is needed.
- **Downstream import failed:** check JSON validity, nullable fields, nested objects, and whether your destination expects flattened columns.

### FAQ

#### What data does this actor collect?

It collects public Zillow property listing records, including listing identity, URLs, pricing, location, property facts, media, metrics, availability, contact details, relationships, and source-specific attributes when available.

#### Can I filter by location, property type, date, price, status, keyword, or other criteria?

Yes. The input schema supports `location`, `deal_type`, `property_type`, `publication_date`, price and payment ranges, bedroom and bathroom thresholds, listing categories, listing statuses, tours, parking, area, building year, amenities, views, `keyword`, and related filters.

#### Why did I receive fewer results than my limit?

The selected filters, location, listing mode, direct URLs, target availability, or public result set may contain fewer matching records than the requested `limit`.

#### What does maximize\_coverage do?

`maximize_coverage` requests deeper collection within the same selected criteria. It does not broaden your filters; it is intended for broad searches where the first visible result set is not enough.

#### Where can I find the run summary or interactive map?

When available, open the actor run output and key-value-store artifacts for `RUN-SUMMARY`, `RUN-SUMMARY.html`, and `results-map`.

#### How should I choose a limit for my first run?

Start with a small `limit`, such as 10 to 25 records, inspect the dataset shape and artifacts, then increase the value for scheduled monitoring, dashboards, CRM imports, or ETL ingestion.

#### Can I schedule recurring runs?

Yes. Use Apify schedules to run the same input daily, weekly, or on a custom cadence.

#### How do I avoid duplicates across runs?

Use `record_id` as the primary key for upserts. Keep `listing.listing_id`, `property.property_id`, `entity.external_ids.zpid`, and `url` as supporting reconciliation fields.

#### Can I use the output with AI agents or automated workflows?

Yes. The actor writes structured JSON records and run artifacts that can be consumed by AI agents, workflow automations, ETL jobs, BI pipelines, and search or vector indexes.

#### Can I export the data to CSV, Excel, or JSON?

Yes. Apify datasets support common export formats including JSON, CSV, Excel, and API-based consumption.

#### Does this actor collect private data or provide official MLS/appraisal data?

No. It is intended for publicly available Zillow information. It does not provide private data, official MLS feeds, appraisal-grade valuation, legal advice, financial advice, investment advice, or brokerage services.

#### What should I include when reporting an issue?

Include the redacted input, run ID, expected behavior, actual behavior, a small output sample if helpful, and downstream destination or export format if the issue is pipeline-related.

### Compliance & Ethics

#### Responsible Data Collection

This actor collects publicly available property listing information from Zillow for legitimate business purposes, including:

- Real estate research and market analysis.
- Listing monitoring, CRM enrichment, and operational review.
- BI, ETL, AI-agent, and internal workflow automation.

This section is informational and not legal advice. Users are responsible for making sure their collection and use of data complies with applicable laws, regulations, platform terms, and internal policies.

#### Best Practices

- Use collected data in accordance with applicable laws, regulations, and the target site's terms.
- Respect individual privacy and personal information.
- Use data responsibly and avoid disruptive or excessive collection.
- Do not use this actor for spamming, harassment, discrimination, unlawful housing practices, or other harmful purposes.
- Follow relevant data protection, fair housing, consumer protection, and sector-specific requirements where applicable.
- Review your own retention, access control, and data-sharing policies before operationalizing the dataset.

### Support

Ask for help through the actor page or Issues. Include the redacted input used, run ID, expected versus actual behavior, a small output sample when useful, and the downstream destination or export format if the issue is pipeline-related.

# Actor input Schema

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

Enter a Zillow-supported market such as Austin, TX; 75001; Brooklyn; or Los Angeles, CA. Use one focused market per run when you need cleaner comparisons, recurring monitoring, or downstream deduplication.

## `deal_type` (type: `string`):

Choose whether the query should collect sale listings, rental listings, or sold listing history. URL seeds remain independent, but this mode is used when building a structured Zillow search.

## `sort_by` (type: `string`):

Select how Zillow should order matching listings before collection. Use newest for monitoring fresh inventory, price sorts for market analysis, or relevance for Zillow's default ranking.

## `min_price` (type: `integer`):

Only include listings with a Zillow price at or above this amount. Pair price ranges with a focused location and listing mode when building comparable market slices for monitoring, dashboards, or ETL ingestion.

## `max_price` (type: `integer`):

Only include listings with a Zillow price at or below this amount. Use this with the minimum price field when you need a bounded price band for reporting, alerts, or CRM enrichment.

## `min_monthly_payment` (type: `integer`):

Only include listings with a Zillow monthly payment estimate at or above this amount. Use payment filters when monthly affordability bands matter more than headline listing price.

## `max_monthly_payment` (type: `integer`):

Only include listings with a Zillow monthly payment estimate at or below this amount. This is useful for affordability monitoring, lead routing, or buyer-profile matching.

## `bedroom_count` (type: `array`):

Select the bedroom threshold to request from Zillow. Use this to keep output focused on comparable property sizes for market analysis, saved searches, or CRM segmentation.

## `bathroom_count` (type: `array`):

Select the bathroom threshold to request from Zillow. Pair it with bedrooms and property type when you need consistent listing slices for dashboards or recurring monitoring.

## `property_type` (type: `array`):

Limit the query to selected Zillow property categories such as houses, condos, apartments, townhomes, manufactured homes, or lots. Leave empty when your workflow should include all supported property types for the chosen market and listing mode.

## `max_hoa` (type: `string`):

Only include listings with HOA fees at or below the selected monthly amount. Use this for buyer-affordability review, community-fee monitoring, or cleaner recurring exports.

## `listing_type` (type: `array`):

Limit results to selected Zillow listing categories such as agent-listed homes, owner-posted homes, new construction, auctions, foreclosures, or pre-foreclosures.

## `listing_status` (type: `array`):

Limit results to selected Zillow status groups such as active, coming soon, pending, under contract, or accepting backup offers. Status filters are useful for inventory monitoring and alert workflows.

## `tours` (type: `array`):

Filter for listings that expose selected visit or presentation options. Use this when your workflow needs open-house monitoring, virtual-tour review, or richer listing presentation signals.

## `min_parking` (type: `string`):

Only include listings with at least the selected number of parking spaces. Use this for car-dependent markets, household-fit filters, or lead qualification workflows.

## `closed_garage` (type: `boolean`):

Enable this to request listings that include garage parking. Leave it off when open parking, driveway parking, or unspecified parking should remain in scope.

## `min_floor_area` (type: `integer`):

Only include listings with interior floor area at or above this square-foot value. Use this for size-based market slices, underwriting review, or comparable-property exports.

## `max_floor_area` (type: `integer`):

Only include listings with interior floor area at or below this square-foot value. Pair it with the minimum floor area field to keep outputs within a targeted size band.

## `min_land_area` (type: `integer`):

Only include listings with lot size at or above this square-foot value. Use this when land area matters for investment review, development screening, or property matching.

## `max_land_area` (type: `integer`):

Only include listings with lot size at or below this square-foot value. Pair it with the minimum lot size field for cleaner land-area comparisons.

## `min_building_year` (type: `integer`):

Only include listings built in or after this year. Use a four-digit year such as 1990 or 2015 when age of construction matters for analysis or qualification.

## `max_building_year` (type: `integer`):

Only include listings built in or before this year. Pair it with the earliest building year field to collect listings from a specific construction era.

## `basement` (type: `boolean`):

Enable this to request listings that mention a basement. Leave it off when basement presence should not affect the query scope.

## `single_story` (type: `boolean`):

Enable this to focus on single-story properties. This is useful for accessibility review, buyer matching, or consistent property comparisons.

## `55_plus_communities` (type: `string`):

Choose whether age-restricted 55+ community listings should remain in scope, be excluded, or be the only listings requested.

## `amenities` (type: `array`):

Select amenities or rental features that matching listings should include. Use amenities to narrow broad markets for tenant-fit, buyer-fit, CRM segmentation, or alert workflows.

## `view` (type: `array`):

Filter for listings with selected view types such as city, mountain, park, or water views. Leave empty when view type should not narrow the dataset.

## `commute_time` (type: `string`):

Enter a destination that Zillow can use for commute-time filtering, such as Downtown Austin or a workplace address. Use this when commute fit is part of lead scoring, relocation review, or saved-search monitoring.

## `price_reduced` (type: `boolean`):

Enable this to focus on listings Zillow marks as price reduced. This is useful for deal monitoring, alerting, repricing analysis, or market-watch workflows.

## `publication_date` (type: `string`):

Limit the query by Zillow's days-on-market window. Use shorter windows for new-listing alerts and longer windows for market analysis or fuller historical review within the selected listing mode.

## `keyword` (type: `string`):

Search Zillow listing text for a keyword or phrase such as pool, waterfront, ADU, furnished, or fixer. Use keywords when structured filters are not specific enough for your workflow.

## `url` (type: `array`):

Paste one supported Zillow URL per line. Use URLs for repeatable monitoring of known searches or specific listings; use the query builder below when you want the actor to create a Zillow search from location, deal type, and filters.

## `maximize_coverage` (type: `boolean`):

Enable this for large location and filter combinations where first-window results are not enough. Leave it off for faster validation runs, narrow saved searches, or workflows where the first visible set of matching listings is sufficient.

## `enrich_data` (type: `boolean`):

Keep this enabled when downstream review, CRM enrichment, BI reporting, or ETL workflows need richer property listing details. Turn it off for faster validation runs when standard search-result fields are enough.

## `mcpConnectors` (type: `array`):

Choose user-authorized MCP connectors for optional post-run delivery of a compact run summary with dataset, summary, and map links when Apify provides them. Leave empty to only save listings to the Apify dataset and key-value store.

## `limit` (type: `integer`):

Choose the maximum number of property records to save for this run. Start small to validate the output shape, then increase it for scheduled monitoring, dashboard refreshes, CRM imports, or ETL ingestion.

## Actor input object example

```json
{
  "location": "Austin, TX",
  "deal_type": "buy",
  "sort_by": "globalrelevanceex",
  "closed_garage": false,
  "basement": false,
  "single_story": false,
  "price_reduced": false,
  "maximize_coverage": true,
  "enrich_data": true,
  "mcpConnectors": [],
  "limit": 100
}
```

# Actor output Schema

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

Structured Zillow property listing records saved by this run. The default dataset is the primary output for exports, BI dashboards, ETL pipelines, CRM enrichment, monitoring workflows, and AI-agent analysis.

## `runSummaryJson` (type: `string`):

Machine-readable end-of-run summary with saved listing counts, input scope, filter summary, enrichment coverage, location coverage, coordinate coverage, top records, and artifact keys.

## `runSummaryHtml` (type: `string`):

Human-readable HTML report for reviewing listing totals, coverage, enrichment, pricing, property facts, location breakdowns, media coverage, and representative records.

## `resultsMap` (type: `string`):

Standalone HTML map for reviewing saved Zillow listing records with valid latitude and longitude values. Runs with no valid coordinates still produce a map report showing zero mapped 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 = {
    "location": "Austin, TX",
    "limit": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("fatihtahta/zillow-property-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "location": "Austin, TX",
    "limit": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("fatihtahta/zillow-property-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

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

```

## CLI example

```bash
echo '{
  "location": "Austin, TX",
  "limit": 100
}' |
apify call fatihtahta/zillow-property-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Zillow Property Scraper with Agents & Description",
        "description": "Extract Zillow property listings at scale with prices, full descriptions, photo galleries, coordinates, property facts, amenities, and agent contacts. Built for market research, comps, inventory monitoring, CRM enrichment, BI, and ETL pipelines.",
        "version": "0.1",
        "x-build-id": "AgF0XmqK66b5Np7jI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fatihtahta~zillow-property-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fatihtahta-zillow-property-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/fatihtahta~zillow-property-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fatihtahta-zillow-property-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/fatihtahta~zillow-property-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fatihtahta-zillow-property-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "location": {
                        "title": "Set a Location (City, State, ZIP Code, Neighborhood, or Market)",
                        "type": "string",
                        "description": "Enter a Zillow-supported market such as Austin, TX; 75001; Brooklyn; or Los Angeles, CA. Use one focused market per run when you need cleaner comparisons, recurring monitoring, or downstream deduplication."
                    },
                    "deal_type": {
                        "title": "Choose the Zillow Listing Mode",
                        "enum": [
                            "buy",
                            "rent",
                            "sold"
                        ],
                        "type": "string",
                        "description": "Choose whether the query should collect sale listings, rental listings, or sold listing history. URL seeds remain independent, but this mode is used when building a structured Zillow search.",
                        "default": "buy"
                    },
                    "sort_by": {
                        "title": "Choose the Zillow Result Sort Order",
                        "enum": [
                            "globalrelevanceex",
                            "days",
                            "priced",
                            "pricea",
                            "paymentd",
                            "paymenta",
                            "beds",
                            "baths",
                            "size",
                            "lot",
                            "zest",
                            "zesta"
                        ],
                        "type": "string",
                        "description": "Select how Zillow should order matching listings before collection. Use newest for monitoring fresh inventory, price sorts for market analysis, or relevance for Zillow's default ranking.",
                        "default": "globalrelevanceex"
                    },
                    "min_price": {
                        "title": "Set the Minimum Asking Price or Rent",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include listings with a Zillow price at or above this amount. Pair price ranges with a focused location and listing mode when building comparable market slices for monitoring, dashboards, or ETL ingestion."
                    },
                    "max_price": {
                        "title": "Set the Maximum Asking Price or Rent",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include listings with a Zillow price at or below this amount. Use this with the minimum price field when you need a bounded price band for reporting, alerts, or CRM enrichment."
                    },
                    "min_monthly_payment": {
                        "title": "Set the Minimum Estimated Monthly Payment",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include listings with a Zillow monthly payment estimate at or above this amount. Use payment filters when monthly affordability bands matter more than headline listing price."
                    },
                    "max_monthly_payment": {
                        "title": "Set the Maximum Estimated Monthly Payment",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include listings with a Zillow monthly payment estimate at or below this amount. This is useful for affordability monitoring, lead routing, or buyer-profile matching."
                    },
                    "bedroom_count": {
                        "title": "Choose the Minimum Bedroom Count",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Select the bedroom threshold to request from Zillow. Use this to keep output focused on comparable property sizes for market analysis, saved searches, or CRM segmentation.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "1",
                                "2",
                                "3",
                                "4",
                                "5"
                            ],
                            "enumTitles": [
                                "1+",
                                "2+",
                                "3+",
                                "4+",
                                "5+"
                            ]
                        }
                    },
                    "bathroom_count": {
                        "title": "Choose the Minimum Bathroom Count",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Select the bathroom threshold to request from Zillow. Pair it with bedrooms and property type when you need consistent listing slices for dashboards or recurring monitoring.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "1",
                                "2",
                                "3",
                                "4",
                                "5"
                            ],
                            "enumTitles": [
                                "1+",
                                "2+",
                                "3+",
                                "4+",
                                "5+"
                            ]
                        }
                    },
                    "property_type": {
                        "title": "Choose Property Types to Include",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Limit the query to selected Zillow property categories such as houses, condos, apartments, townhomes, manufactured homes, or lots. Leave empty when your workflow should include all supported property types for the chosen market and listing mode.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "houses",
                                "condos_coops",
                                "apartments_condos_coops",
                                "multi_family",
                                "apartments",
                                "manufactured",
                                "lots_land",
                                "townhomes",
                                "room",
                                "entire_place"
                            ],
                            "enumTitles": [
                                "Houses",
                                "Condos/Co-ops",
                                "Apartments/Condos/Co-ops",
                                "Multi-family",
                                "Apartments",
                                "Manufactured",
                                "Lots/Land",
                                "Townhomes",
                                "Room",
                                "Entire place"
                            ]
                        }
                    },
                    "max_hoa": {
                        "title": "Set the Maximum Monthly HOA Fee",
                        "enum": [
                            "0",
                            "50",
                            "100",
                            "200",
                            "300",
                            "400",
                            "500",
                            "600",
                            "700",
                            "800",
                            "900",
                            "1000",
                            "1500",
                            "2000"
                        ],
                        "type": "string",
                        "description": "Only include listings with HOA fees at or below the selected monthly amount. Use this for buyer-affordability review, community-fee monitoring, or cleaner recurring exports."
                    },
                    "listing_type": {
                        "title": "Choose Listing Source and Ownership Categories",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Limit results to selected Zillow listing categories such as agent-listed homes, owner-posted homes, new construction, auctions, foreclosures, or pre-foreclosures.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "agent_listed",
                                "owner_posted",
                                "new_construction",
                                "foreclosures",
                                "auctions",
                                "foreclosed",
                                "pre_foreclosures"
                            ],
                            "enumTitles": [
                                "Agent-listed homes",
                                "Owner-posted homes",
                                "New construction",
                                "Foreclosure listings",
                                "Auction listings",
                                "Foreclosed homes",
                                "Pre-foreclosures"
                            ]
                        }
                    },
                    "listing_status": {
                        "title": "Choose Listing Statuses to Include",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Limit results to selected Zillow status groups such as active, coming soon, pending, under contract, or accepting backup offers. Status filters are useful for inventory monitoring and alert workflows.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "active",
                                "coming_soon",
                                "zillow_preview",
                                "pending_under_contract",
                                "accepting_backup_offers"
                            ],
                            "enumTitles": [
                                "Active",
                                "Coming soon",
                                "Zillow Preview",
                                "Pending & under contract",
                                "Accepting backup offers"
                            ]
                        }
                    },
                    "tours": {
                        "title": "Require Open House, 3D Tour, or Showcase Signals",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Filter for listings that expose selected visit or presentation options. Use this when your workflow needs open-house monitoring, virtual-tour review, or richer listing presentation signals.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "open_house",
                                "3d_tour",
                                "showcase"
                            ],
                            "enumTitles": [
                                "Open house",
                                "3D tour",
                                "Showcase listing"
                            ]
                        }
                    },
                    "min_parking": {
                        "title": "Choose the Minimum Parking Capacity",
                        "enum": [
                            "1+",
                            "2+",
                            "3+",
                            "4+"
                        ],
                        "type": "string",
                        "description": "Only include listings with at least the selected number of parking spaces. Use this for car-dependent markets, household-fit filters, or lead qualification workflows."
                    },
                    "closed_garage": {
                        "title": "Require a Garage",
                        "type": "boolean",
                        "description": "Enable this to request listings that include garage parking. Leave it off when open parking, driveway parking, or unspecified parking should remain in scope.",
                        "default": false
                    },
                    "min_floor_area": {
                        "title": "Set the Minimum Floor Area",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include listings with interior floor area at or above this square-foot value. Use this for size-based market slices, underwriting review, or comparable-property exports."
                    },
                    "max_floor_area": {
                        "title": "Set the Maximum Floor Area",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include listings with interior floor area at or below this square-foot value. Pair it with the minimum floor area field to keep outputs within a targeted size band."
                    },
                    "min_land_area": {
                        "title": "Set the Minimum Lot Size",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include listings with lot size at or above this square-foot value. Use this when land area matters for investment review, development screening, or property matching."
                    },
                    "max_land_area": {
                        "title": "Set the Maximum Lot Size",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include listings with lot size at or below this square-foot value. Pair it with the minimum lot size field for cleaner land-area comparisons."
                    },
                    "min_building_year": {
                        "title": "Set the Earliest Building Year",
                        "type": "integer",
                        "description": "Only include listings built in or after this year. Use a four-digit year such as 1990 or 2015 when age of construction matters for analysis or qualification."
                    },
                    "max_building_year": {
                        "title": "Set the Latest Building Year",
                        "type": "integer",
                        "description": "Only include listings built in or before this year. Pair it with the earliest building year field to collect listings from a specific construction era."
                    },
                    "basement": {
                        "title": "Require Basement Mentions",
                        "type": "boolean",
                        "description": "Enable this to request listings that mention a basement. Leave it off when basement presence should not affect the query scope.",
                        "default": false
                    },
                    "single_story": {
                        "title": "Require Single-Story Listings",
                        "type": "boolean",
                        "description": "Enable this to focus on single-story properties. This is useful for accessibility review, buyer matching, or consistent property comparisons.",
                        "default": false
                    },
                    "55_plus_communities": {
                        "title": "Choose How to Treat 55+ Communities",
                        "enum": [
                            "include",
                            "exclude",
                            "only"
                        ],
                        "type": "string",
                        "description": "Choose whether age-restricted 55+ community listings should remain in scope, be excluded, or be the only listings requested."
                    },
                    "amenities": {
                        "title": "Require Amenities or Rental Features",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Select amenities or rental features that matching listings should include. Use amenities to narrow broad markets for tenant-fit, buyer-fit, CRM segmentation, or alert workflows.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "air_conditioning",
                                "pool",
                                "waterfront",
                                "disabled_access",
                                "hardwood_floors",
                                "utilities_included",
                                "fitness_center",
                                "dishwasher",
                                "high_speed_internet",
                                "elevator",
                                "furnished",
                                "outdoor_space",
                                "pets_allowed",
                                "in_unit_laundry",
                                "short_term_lease",
                                "controlled_access",
                                "no_pets",
                                "promotion"
                            ],
                            "enumTitles": [
                                "Air conditioning",
                                "Pool",
                                "Waterfront",
                                "Disabled access",
                                "Hardwood floors",
                                "Utilities included",
                                "Fitness center",
                                "Dishwasher",
                                "High speed internet",
                                "Elevator",
                                "Furnished",
                                "Outdoor space",
                                "Pets allowed",
                                "In-unit laundry",
                                "Short term lease",
                                "Controlled access",
                                "No pets",
                                "Promotion"
                            ]
                        }
                    },
                    "view": {
                        "title": "Require Specific View Types",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Filter for listings with selected view types such as city, mountain, park, or water views. Leave empty when view type should not narrow the dataset.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "city",
                                "mountain",
                                "park",
                                "water"
                            ],
                            "enumTitles": [
                                "City view",
                                "Mountain view",
                                "Park view",
                                "Water view"
                            ]
                        }
                    },
                    "commute_time": {
                        "title": "Set a Commute Destination",
                        "type": "string",
                        "description": "Enter a destination that Zillow can use for commute-time filtering, such as Downtown Austin or a workplace address. Use this when commute fit is part of lead scoring, relocation review, or saved-search monitoring."
                    },
                    "price_reduced": {
                        "title": "Only Include Listings With a Price Reduction",
                        "type": "boolean",
                        "description": "Enable this to focus on listings Zillow marks as price reduced. This is useful for deal monitoring, alerting, repricing analysis, or market-watch workflows.",
                        "default": false
                    },
                    "publication_date": {
                        "title": "Limit by Listing Freshness",
                        "enum": [
                            "any",
                            "1",
                            "7",
                            "14",
                            "30",
                            "90",
                            "6m",
                            "12m",
                            "24m",
                            "36m"
                        ],
                        "type": "string",
                        "description": "Limit the query by Zillow's days-on-market window. Use shorter windows for new-listing alerts and longer windows for market analysis or fuller historical review within the selected listing mode."
                    },
                    "keyword": {
                        "title": "Search for a Keyword or Phrase",
                        "type": "string",
                        "description": "Search Zillow listing text for a keyword or phrase such as pool, waterfront, ADU, furnished, or fixer. Use keywords when structured filters are not specific enough for your workflow."
                    },
                    "url": {
                        "title": "Add Direct Zillow URLs (Search Pages, Map/List Pages, or Listings)",
                        "type": "array",
                        "description": "Paste one supported Zillow URL per line. Use URLs for repeatable monitoring of known searches or specific listings; use the query builder below when you want the actor to create a Zillow search from location, deal type, and filters.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maximize_coverage": {
                        "title": "Collect More Matching Listings From Broad Searches",
                        "type": "boolean",
                        "description": "Enable this for large location and filter combinations where first-window results are not enough. Leave it off for faster validation runs, narrow saved searches, or workflows where the first visible set of matching listings is sufficient.",
                        "default": true
                    },
                    "enrich_data": {
                        "title": "Collect Richer Details From Individual Listing Pages",
                        "type": "boolean",
                        "description": "Keep this enabled when downstream review, CRM enrichment, BI reporting, or ETL workflows need richer property listing details. Turn it off for faster validation runs when standard search-result fields are enough.",
                        "default": true
                    },
                    "mcpConnectors": {
                        "title": "MCP Delivery Connectors",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Choose user-authorized MCP connectors for optional post-run delivery of a compact run summary with dataset, summary, and map links when Apify provides them. Leave empty to only save listings to the Apify dataset and key-value store.",
                        "default": []
                    },
                    "limit": {
                        "title": "Set the Maximum Number of Listings to Save",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Choose the maximum number of property records to save for this run. Start small to validate the output shape, then increase it for scheduled monitoring, dashboard refreshes, CRM imports, or ETL ingestion."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```