# Zillow Property Details Scraper (`scraper-engine/zillow-property-details-scraper`) Actor

Zillow Property Details Scraper extracts public property data including prices, addresses, home types, bedrooms, bathrooms, square footage, lot size, amenities, listing status, agent details, and property URLs for real estate research and market analysis.

- **URL**: https://apify.com/scraper-engine/zillow-property-details-scraper.md
- **Developed by:** [Scraper Engine](https://apify.com/scraper-engine) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.99 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

### Zillow Property Scraper — Price, Zestimate, Tax History and Photos

Zillow Property Scraper pulls the full public record for any Zillow property — price, Zestimate, bedrooms and bathrooms, tax and price history, schools, nearby homes and photos — from a URL, a bare ZPID, or a plain street address. Every run returns clean, structured JSON on the same fixed schema every time, so field names never shift between runs. Paste one address or hundreds of URLs and ZPIDs in a single input list. Start a run on Apify and watch the first property land in your dataset.

### 🏠 What is Zillow Property Scraper?

Zillow Property Scraper is an Apify Actor that fetches a Zillow property's detail page plus its companion GraphQL modules and normalizes everything into one JSON record — price and facts, Zestimate, tax and price history, schools, nearby homes, photos, and listing information. No Zillow account or login is required: every field returned is exactly what a logged-out visitor can see on the public listing page. It's built for real estate developers, market analysts, and AI engineers who need structured property data without maintaining their own scraping pipeline.

### 📋 What Zillow property data is publicly available to scrape?

Anyone can open a Zillow listing without logging in and see its price, facts, history and photos — that's exactly what this Actor returns.

| Data Category | Publicly Available | Restricted (owner/agent login) |
| --- | --- | --- |
| Core facts — address, price, beds/baths, home type, year built | Yes | — |
| Zestimate, Rent Zestimate, tax history, price history | Yes | — |
| Listing agent name, brokerage, MLS ID | Yes | — |
| Schools and nearby comparable homes | Yes | — |
| Photos, virtual tour and floor plan links | Yes | — |
| Owner/agent portal status flags and management links | — | Yes |
| BuyAbility financing pre-qualification data | — | Yes |

Zillow Property Scraper only returns publicly visible data — what any visitor sees on the listing page. Nothing behind a login wall.

⚠️ The schema also carries a handful of owner/agent-portal fields — `isListingClaimedByCurrentSignedInUser`, `isCurrentSignedInAgentResponsible`, `isCurrentSignedInUserVerifiedOwner`, `propertyUpdatePageLink`, `moveHomeMapLocationLink`, `propertyEventLogLink`, `editPropertyHistorylink`, and `buyAbilityData`. They exist for schema completeness, but since the scraper never authenticates, they read `null` or `false` in every row.

### 🗂️ What data can I extract with Zillow Property Scraper?

Every run returns one record per property covering identity and location, price and quantitative facts, and history/media modules — 186 fields in total, projected onto the same schema whether Zillow exposes the value or not.

#### Location & identity fields

| Field Name | Description |
| --- | --- |
| `zpid` | Zillow's unique property ID |
| `streetAddress` / `city` / `state` / `zipcode` / `county` | Parsed street address components |
| `address` | Structured address object |
| `hdpUrl` | Canonical Zillow property URL |
| `homeStatus` | Listing status (for sale, pending, sold, off-market, etc.) as returned by Zillow |
| `homeType` | Property type (single family, condo, townhouse, etc.) |
| `yearBuilt` | Year the structure was built |
| `latitude` / `longitude` | Geocoordinates |
| `description` / `whatILove` | Listing description text |

#### Price & quantitative fields

| Field Name | Description |
| --- | --- |
| `price` / `currency` | Current listing price and currency |
| `bedrooms` / `bathrooms` | Bed and bath counts |
| `livingArea` / `livingAreaValue` / `livingAreaUnits` | Interior square footage |
| `lotSize` / `lotAreaValue` / `lotAreaUnits` | Lot size |
| `zestimate` / `rentZestimate` | Zillow's automated value and rent estimates |
| `zestimateLowPercent` / `zestimateHighPercent` | Zestimate confidence range bounds |
| `priceHistory` | Array of past list/sale price events |
| `taxHistory` | Array of past assessed value and tax events |
| `propertyTaxRate` / `monthlyHoaFee` | Tax rate and HOA fee |
| `daysOnZillow` / `photoCount` | Listing age and photo count |

#### History & media modules

| Field Name | Description |
| --- | --- |
| `schools` | Array of nearby schools with ratings and distance |
| `nearbyHomes` | Array of comparable nearby properties |
| `originalPhotos` | Full-resolution photo array |
| `hiResImageLink` / `mediumImageLink` / `thumb` | Derived photo variants at fixed sizes |
| `virtualTourUrl` / `interactiveFloorPlanUrl` | Virtual tour and floor plan links |
| `listedBy` / `attributionInfo` / `brokerageName` / `mlsid` | Listing agent, brokerage and MLS identifiers |
| `mortgageRates` / `mortgageZHLRates` / `annualHomeownersInsurance` | Financing estimate modules |

### 🔑 How to use Zillow Property Scraper

Zillow Property Scraper runs on the Apify platform — there's no separate signup or API key beyond an Apify account.

1. Open Zillow Property Scraper on its Apify Store listing.
2. Provide the required input — `startUrls`: one or more Zillow property URLs, bare ZPIDs, or street addresses, one per line.
3. Optionally link `searchResultsDatasetId` to a dataset from a Zillow search/listing scraper to enrich every property it found, or configure `proxyConfiguration` to start on a specific proxy tier instead of the automatic no-proxy default.
4. Click **Start** (or call the Actor via the Apify API).
5. Open the Output tab to browse results across the Overview, Location, Building, Financials, Schools, Nearby Homes, Media and Listing views, or export as JSON, CSV or Excel.

#### How to scale to bulk property extraction

`startUrls` is an array (the stringList editor), so a single run accepts as many URLs, ZPIDs or addresses as you paste in — one per line, no separate run per property required. Every property in the list is fetched independently and pushed to the dataset the moment it's ready, so a crash or stop mid-run still leaves you with whatever was already scraped instead of losing the whole batch.

### 💡 What can you do with Zillow property data?

- 📈 An investment analyst tracking a market uses `priceHistory` and `taxHistory` together to spot properties with a widening gap between assessed value and list price.
- 🏗️ A real estate developer scoping a lot uses `lotAreaValue`, `resoFacts` and `homeType` to shortlist parcels before requesting a survey.
- 🏫 A relocation service comparing neighborhoods uses `schools` and `nearbyHomes` to build a comparable-homes report for a family evaluating a specific address.
- 🤝 A lead-generation team building outreach lists uses `attributionInfo`, `listedBy` and `brokerageName` to identify which agent or brokerage represents a given property.
- 🤖 An AI agent building a property-valuation tool feeds `price`, `zestimate`, `livingArea`, `bedrooms`, `bathrooms` and `description` into a RAG pipeline so it can answer natural-language questions about a specific address with grounded, structured facts instead of guessing.

### 🛡️ Why not build this yourself?

Zillow's property page serves its data through a server-rendered `__NEXT_DATA__` JSON blob whose wrapper object name changes depending on listing status, plus a separate GraphQL endpoint (`ForSaleNonPriorityQuery`) and a handful of persisted-query hashes for bonus modules like mortgage rates and home valuations — hashes Zillow rotates periodically, so a hardcoded query breaks silently until you re-discover the new one. On top of that, Zillow's PerimeterX bot defense blocks a plain HTTP client almost immediately; getting past it takes a warmed session and a real browser TLS fingerprint, and when that's still not enough, escalating through paid datacenter and residential proxy tiers. Zillow Property Scraper handles all of that automatically and defaults to no proxy at all, so you only pay for a higher tier when a request is actually blocked.

### ⛔ How does Zillow Property Scraper handle rate limits and blocking?

Every property starts with no proxy at all. If a request comes back blocked — a non-200 status, a PerimeterX challenge page, or a network error — the shared proxy tier for the whole run escalates: No proxy → Datacenter proxy → Residential proxy, and once Residential is reached, every property in the run stays on it (the tier only ever moves up, never back down, and a block discovered by one property benefits every other property running concurrently). Each property is retried up to six times, with growing delays and a rotated mobile-Safari session fingerprint on every attempt, plus up to three additional retries once already on Residential. If every attempt is exhausted, that property is skipped — no partial or fabricated row is pushed for it — and the run log records the reason (HTTP status, "blocked or empty response", or the exception name) so you can see exactly which inputs failed and why.

### ⬇️ Input

Zillow Property Scraper takes three input fields, defined in `.actor/input_schema.json`. Only `startUrls` is required.

| Parameter | Required | Type | Description | Example Value |
| --- | --- | --- | --- | --- |
| `startUrls` | Yes | Array of strings | Zillow property links, bare ZPIDs, or full street addresses — one per line. Bulk input supported. | `"https://www.zillow.com/homedetails/7413-First-Landing-Ct-Henrico-VA-23231/72095256_zpid/"` |
| `searchResultsDatasetId` | No | Array | Dataset ID(s) from a Zillow search/listing scraper, used to enrich every property found there with full details. | `"AbCdEfGhIjKlMnOp01"` |
| `proxyConfiguration` | No | Object | Apify Proxy configuration. Default is no proxy; the run auto-escalates to Datacenter then Residential only if a request is blocked. | `{ "useApifyProxy": false }` |

#### Example input

```json
{
  "startUrls": [
    "https://www.zillow.com/homedetails/7413-First-Landing-Ct-Henrico-VA-23231/72095256_zpid/",
    "21386 Sunnyside Rd, Los Gatos, CA 95033",
    "24996529"
  ],
  "searchResultsDatasetId": [],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

### ⬆️ Output

Zillow Property Scraper pushes one dataset item per property, every item projected onto the same 186-key schema in the same order — a field Zillow doesn't expose for that particular property comes back as `null` instead of being left out, so every row has an identical shape. Open the Output tab to browse it split into Overview, Location, Building, Financials, Schools, Nearby Homes, Media and Listing views, or export the whole dataset as JSON, CSV or Excel. The Actor bills on the `row_result` event, charged once per property that's actually pushed to the dataset — a property that fails every retry produces no row and is never charged.

#### Example output

```json
{
  "zpid": 72095256,
  "hdpUrl": "https://www.zillow.com/homedetails/7413-First-Landing-Ct-Henrico-VA-23231/72095256_zpid/",
  "homeStatus": "FOR_SALE",
  "streetAddress": "7413 First Landing Ct",
  "city": "Henrico",
  "state": "VA",
  "zipcode": "23231",
  "county": "Henrico County",
  "price": 435000,
  "currency": "USD",
  "bedrooms": 4,
  "bathrooms": 3,
  "livingArea": 2648,
  "livingAreaUnits": "Square Feet",
  "lotSize": 12197,
  "lotAreaUnits": "Square Feet",
  "yearBuilt": 2015,
  "homeType": "SINGLE_FAMILY",
  "zestimate": 441200,
  "rentZestimate": 2450,
  "latitude": 37.4831,
  "longitude": -77.3175,
  "daysOnZillow": 12,
  "photoCount": 38,
  "description": "Beautifully maintained colonial in the sought-after First Landing community...",
  "priceHistory": [
    { "date": "2024-06-01", "event": "Listed for sale", "price": 435000 }
  ],
  "taxHistory": [
    { "year": 2023, "taxPaid": 3210, "value": 398000 }
  ],
  "schools": [
    { "name": "Varina High School", "rating": 4, "level": "High", "distance": 2.1 }
  ],
  "listedBy": [
    { "displayName": "Jane Smith", "phone": "(804) 555-0100" }
  ],
  "brokerageName": "Long & Foster Real Estate",
  "mlsid": "2412345",
  "hiResImageLink": "https://photos.zillowstatic.com/fp/abc123def456-p_f.jpg",
  "virtualTourUrl": null
}
```

### ⚙️ How does it work?

Zillow Property Scraper runs each property through a short request pipeline over a session that mimics a real mobile Safari browser at the TLS fingerprint level. It first warms the session against Zillow's homepage, then fetches the property detail page — resolving the ZPID for address or bare-ZPID input in the process — by recursively searching the page's embedded `__NEXT_DATA__` JSON for the object carrying that ZPID, rather than a fixed path, so the parser keeps working even when Zillow renames its wrapper objects. A second request hits Zillow's own GraphQL endpoint for the richer modules (price history, tax history, schools, nearby homes, description), and a few best-effort requests fill in bonus modules like mortgage rates when available. Every source is merged, real values always winning over nulls, and projected onto the same fixed schema every run — so your downstream code never has to handle a shifting shape. Only what a logged-out visitor can see is ever returned.

⚠️ The mortgage-rate, home-insights and home-valuation modules are addressed by a persisted GraphQL query hash that Zillow rotates from time to time. When a hash goes stale, those specific fields come back `null` for that run instead of breaking it — every other field is unaffected.

### 🔌 Integrations

Zillow Property Scraper works with what you already use — call it directly from your own code, wire it into an AI agent over MCP, or drop it into a no-code automation.

#### Calling Zillow Property Scraper programmatically

```python
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("scraper-engine/zillow-property-details-scraper").call(
    run_input={"startUrls": ["21386 Sunnyside Rd, Los Gatos, CA 95033"]}
)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["zpid"], item["price"], item["zestimate"])
```

Works in Go, Ruby, Node.js, cURL — any language that can make an HTTP request.

#### MCP integration for AI agents

Zillow Property Scraper is reachable through Apify's MCP server at `mcp.apify.com`. Register it with the Apify CLI — `apify mcp install claude-code --tools scraper-engine/zillow-property-details-scraper` — or add `https://mcp.apify.com?tools=scraper-engine/zillow-property-details-scraper` as a custom MCP server URL in Claude Desktop. The CLI installs the same way for Cursor, VS Code, Codex, Kiro and Antigravity, giving any of them the Actor's input schema as a tool and its dataset rows as the tool result.

#### No-code tools (n8n, Make, LangChain)

In n8n, add the official Apify node (`@apify/n8n-nodes-apify`) to run this Actor and read its dataset items directly inside a workflow, no manual HTTP Request node needed. In Make, use Apify's app modules — **Run an Actor**, pointed at `zillow-property-details-scraper`, then **Get Dataset Items** — to drop property data straight into a scenario. In LangChain, `ApifyWrapper.call_actor()` runs this Actor and hands back an `ApifyDatasetLoader` you can feed directly into a retriever or vector store.

### ⚖️ Is it legal to scrape Zillow properties?

Scraping publicly available Zillow property listings — addresses, prices, home facts, tax records and photos already published for any visitor to see — is generally lawful and sits under contract and database-rights law rather than data-protection law. Zillow Property Scraper only returns what a logged-out visitor can already see on the listing page, so this is business/product data, and GDPR does not attach to it. The one exception is the listing-agent fields — `listedBy`, `attributionInfo`, `postingContact` and `brokerageName` — which do carry a named individual's professional contact details; if you store or reuse those at scale, GDPR/CCPA's lawful-basis rules for personal data can apply to that subset. Always review Zillow's Terms of Service for your specific use case, and consult legal counsel if your use case involves bulk storage of personal data.

### ❓ Frequently asked questions

#### What Zillow property fields does Zillow Property Scraper return?

The five most-used fields are `price`, `zestimate`, `bedrooms`, `bathrooms` and `homeStatus`, alongside 180+ others covering location, history, schools and media — see [What data can I extract](#-what-data-can-i-extract-with-zillow-property-scraper) above for the full breakdown.

#### Does Zillow Property Scraper require a Zillow account or login?

No. The Actor runs an anonymous session against Zillow's public pages and never authenticates — which is also why the owner/agent-portal fields in the schema always come back `null` or `false`.

#### How many properties can I extract in one run?

As many as you list in `startUrls`. It's an array field with no fixed cap in the input schema, and each property is processed and pushed to the dataset independently of the others.

#### What happens if a property is off-market, delisted, or the input doesn't resolve to a real listing?

If Zillow still serves a page for a former listing, `homeStatus` reflects that directly (Zillow's own status value). If the URL, ZPID or address never resolves to a real property page after every retry, that item is skipped entirely — no row is pushed for it, and the run log records the reason, so a shorter dataset than your input list tells you exactly which inputs failed.

#### Can I scrape multiple Zillow properties at once?

Yes. `startUrls` accepts a list — paste as many URLs, ZPIDs or addresses as you want, one per line, and they're all scraped in the same run.

#### Does Zillow Property Scraper work with Claude, ChatGPT, and other AI agent tools?

Yes. It's reachable through Apify's MCP server (see Integrations above), and any other agent framework can call it as a plain HTTP endpoint through the Apify API.

#### What's the difference between using a URL/ZPID versus a street address as input?

A URL or bare ZPID goes straight to the property's detail page. A street address is first resolved through Zillow's own search, so the ZPID is only known once the property page loads — it depends on Zillow matching the address to a real listing.

#### Does Zillow Property Scraper return data in a format LLMs can use directly?

Yes. Every record is typed, normalized JSON with the same field names on every run — no HTML parsing, no CSS selectors. Pass it directly to an LLM, index it into a vector store, or feed it to an agent tool.

#### What happens when Zillow changes its layout or anti-bot system?

The parser locates the property object by recursively searching for the dict that carries the matching ZPID rather than a fixed JSON path, so it keeps working when Zillow renames a wrapper object, and the output schema stays the same 186 keys regardless. The bonus GraphQL modules addressed by a persisted query hash are treated as best-effort and simply come back empty if Zillow rotates that hash, without affecting the rest of the record.

#### Can I use Zillow Property Scraper without managing proxies or browser infrastructure?

Yes. The default is no proxy at all, and the Actor only escalates to Apify's Datacenter and then Residential proxy tiers automatically when a request is actually blocked — you never configure sessions, fingerprints, or retries yourself.

#### Which Zillow property fields work best for AI training data and RAG indexing?

For RAG, index `description` and `whatILove` — the highest-information free text in the record. For structured training data, `zpid`, `price`, `bedrooms`, `bathrooms`, `livingArea`, `homeType`, `zestimate` and `yearBuilt` return as consistent typed primitives on every record, since every property is projected onto the same fixed schema.

### 🔗 Related scrapers

| Scraper | What it extracts |
| --- | --- |
| Website Content Crawler | General-purpose page crawler — pair it with Zillow Property Scraper to pull unstructured pages Zillow doesn't expose as structured fields, like agent bio pages or neighborhood guide content. |

### 💬 Your feedback

Found a bug or missing a field? Let us know — email **dev.scraperengine@gmail.com** for custom solutions, feature requests, or to report an issue. Active maintenance means the schema and parser get updated as Zillow's site changes.

# Actor input Schema

## `startUrls` (type: `array`):

🏘️ Add one or more Zillow property links (e.g. https://www.zillow.com/homedetails/...), bare ZPIDs (e.g. 72095256), or full street addresses — one per line. Supports bulk input — paste a whole list at once.

## `searchResultsDatasetId` (type: `array`):

🔄 Feed in dataset(s) produced by a Zillow search/listing scraper to enrich every property found there with full details. Fully optional — the field above already works standalone.

## `proxyConfiguration` (type: `object`):

🌐 Default is **No proxy** — requests go straight to Zillow. If a request gets blocked, the run automatically escalates: No proxy → 🖥️ Datacenter proxy → 🏡 Residential proxy (retried up to 3×), then stays on Residential for the rest of the run. Turn on Apify Proxy here only if you want to start on a specific tier yourself.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.zillow.com/homedetails/7413-First-Landing-Ct-Henrico-VA-23231/72095256_zpid/",
    "21386 Sunnyside Rd, Los Gatos, CA 95033",
    "24996529"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

Core facts for every property: address, price, beds/baths, size, status.

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

Address, coordinates, county and nearby areas.

## `building` (type: `string`):

Construction, size and the full RESO facts object.

## `financials` (type: `string`):

Price, Zestimate, tax history, price history and mortgage info.

## `schools` (type: `string`):

Nearby schools and GreatSchools ratings.

## `nearbyHomes` (type: `string`):

Comparable homes near this property.

## `media` (type: `string`):

Photos, virtual tours and video links.

## `listing` (type: `string`):

Attribution, MLS info, agent/broker details and the full description.

## `fullRecord` (type: `string`):

Every field the scraper extracts, in one flat table.

## `resultsJson` (type: `string`):

All results as raw JSON via the API.

## `resultsCsv` (type: `string`):

All results as a downloadable CSV.

# 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 = {
    "startUrls": [
        "https://www.zillow.com/homedetails/7413-First-Landing-Ct-Henrico-VA-23231/72095256_zpid/",
        "21386 Sunnyside Rd, Los Gatos, CA 95033",
        "24996529"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraper-engine/zillow-property-details-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 = {
    "startUrls": [
        "https://www.zillow.com/homedetails/7413-First-Landing-Ct-Henrico-VA-23231/72095256_zpid/",
        "21386 Sunnyside Rd, Los Gatos, CA 95033",
        "24996529",
    ],
    "proxyConfiguration": { "useApifyProxy": False },
}

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

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

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

```

## CLI example

```bash
echo '{
  "startUrls": [
    "https://www.zillow.com/homedetails/7413-First-Landing-Ct-Henrico-VA-23231/72095256_zpid/",
    "21386 Sunnyside Rd, Los Gatos, CA 95033",
    "24996529"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scraper-engine/zillow-property-details-scraper --silent --output-dataset

```

## MCP server setup

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

```

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

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/25cSWbf8GDwhrQjvX/builds/NvGcoWrytpS2MEwwq/openapi.json