# Zillow Listings Scraper & Price Intelligence (`zapticx/zillow-market-intelligence`) Actor Scrape current Zillow for-sale listings and compare price per sqft, Zestimate delta, and days on market against transparent active-listing comparables. - **URL**: https://apify.com/zapticx/zillow-market-intelligence.md - **Developed by:** [Zapticx](https://apify.com/zapticx) (community) - **Categories:** Real estate, Lead generation - **Stats:** 2 total users, 1 monthly users, 90.6% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing $2.00 / 1,000 listings 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 Listings Scraper & Price Intelligence Scrape current Zillow for-sale listings and turn them into a practical read on pricing, not just a row dump. Every listing comes back with a price-per-sqft percentile against comparable nearby homes, a Zestimate delta, a days-on-market signal, and a confidence score — so you can tell a priced-right listing from an overpriced one at a glance. This Actor keeps observed source data separate from Actor-derived intelligence, so you get usable benchmarks without opaque claims about occupancy, appreciation, or investment returns. **What "comparable" means here:** the comparable set is the collected population of *active* Zillow for-sale listings matching the same ZIP/home type/bedroom segment — not a broker CMA, an appraisal, or an analysis of verified closed sales. Treat the intelligence output as a market-rate read against current asking prices, not a substitute for professional valuation. This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Zillow Group, Inc. "Zillow" and "Zestimate" are trademarks of Zillow, Inc. ### Quick start 1. Type a market into **Location** — `Miami Beach, FL`, `33139`, or `Austin, TX`. 2. Optionally set **Number of listings** (default 100, max 820). 3. Click **Start**. That is the whole basic path. A 100-listing run finishes in about 10 seconds and costs $0.20. Everything else on the form is optional. ```json { "location": "Miami Beach, FL", "maxResults": 100 } ``` ### What this Actor does **Zillow search → normalized listings → comparable-set selection → price/Zestimate/DOM intelligence → market summary** Provide a location (or a Zillow search-results URL) and optional price/bed/bath/home-type filters. The Actor collects up to 820 unique listings — Zillow's own per-search cap — selects a comparable set for each one (same ZIP + home type + bedroom count, falling back to looser tiers when that's too small), and scores it against that set. A `market_summary` record with aggregate pricing, coverage, and distribution stats for the whole run is written to the key-value store (not the dataset — see Output below). ### Why use it? Most Zillow scrapers stop at rows of listing data. This Actor also answers practical questions: - Is this listing priced below, near, or above comparable homes nearby? - How far off is the list price from Zillow's own Zestimate? - Is it moving faster or slower than similar listings? - How large and specific was the comparable sample, and how much should you trust it? The methodology is deterministic and documented below. Missing evidence stays `null` with a reason code instead of being guessed or silently dropped. ### Key features - Location or direct Zillow search-URL input, with server-side price/bed/bath/home-type filters - Normalized address, pricing, size, and listing-status fields - Price-per-sqft percentile and delta-from-median against a selected comparable set - Plain-language price position: budget, below market, market, above market, or premium - Zestimate delta (independent of comparable-set size — shown whenever a Zestimate exists) - Days-on-market delta versus the comparable set's median - Comparable-set tiers based on ZIP + home type + bedrooms, with transparent fallback - Per-listing and market-wide confidence scoring with reason codes - No per-property detail-page fetches needed — the full intelligence layer comes from one search request per ~41 listings, keeping cost low - Explicit limitations and transparent null handling - Apify datasets ready for JSON, CSV, Excel, APIs, and automation workflows ### Who is it for? Real-estate investors and flippers doing comps, agents and brokers pricing a listing, short-term and long-term rental analysts, buyers sanity-checking a price, and researchers or agencies building market snapshots. Common uses: "is this listing overpriced" checks, comp-set research for an offer, market pricing snapshots by ZIP or neighborhood, and feeding a normalized dataset into a BI tool or spreadsheet. ### Data source Zillow's public "GetSearchResults" API (and its siblings `GetZestimate`/`GetComps`) was permanently shut down on September 30, 2021 — no waiting list, no new keys issued. The only official successor is [Bridge Interactive](https://www.bridgeinteractive.com/developers/bridge-api/), an enterprise RESO Web API restricted to MLS-affiliated brokerages and approved proptech partners, with a weeks-to-months approval process; it is not available to an individual developer building a Store actor. This Actor instead reads the same structured `__NEXT_DATA__` JSON payload Zillow's own search page embeds and renders client-side — verified against the live site, not assumed — using the already-published, publicly-served page data rather than any authenticated or gated endpoint. ### Input #### Search | Field | Required | Description | | --- | --- | --- | | `location` | One search input | City, state, ZIP, county, or neighborhood — e.g. `Miami Beach, FL`, `33139`, `Wynwood, Miami, FL`. Use exactly one of `location`, `searchUrl`, or `targetUrl`. | | `maxResults` | No | Unique listing cap, 1–820; default 100. Zillow caps a single search around 820 total. | | `listingType` | No | For-sale listings only in this version; `for_sale` is the only value. | | `searchUrl` | One search input | A full zillow.com search-results URL used instead of `location`, for filters this Actor does not expose. | | `targetUrl` | One search input | A single `zillow.com/homedetails/...` listing URL. Fetches just that one property — no search, no comparable-set intelligence, no `market_summary` — as one `target_listing` record. Adds three fields search results never carry: `yearBuilt`, `monthlyHoaFee`, and `propertyTaxRate` (all real observed data, only present when Zillow publishes them). | #### Filters (optional) | Field | Required | Description | | --- | --- | --- | | `homeTypes` | No | Restrict to specific home types. Leave empty for all. | | `priceMin` / `priceMax` | No | List-price range in USD. | | `bedsMin` / `bathsMin` | No | Minimum bedrooms / bathrooms. | Filters are applied by Zillow before results come back, so they also define the comparable population every percentile is measured against — see [Sample-selection bias](#sample-selection-bias). #### Advanced | Field | Required | Description | | --- | --- | --- | | `proxyConfiguration` | No | Apify Proxy; used only as a retry fallback after a direct attempt. | #### Example inputs ##### Quick market scan (defaults only) ```json { "location": "Miami Beach, FL" } ``` ##### Condo comps in a price band ```json { "location": "Miami Beach, FL", "homeTypes": ["CONDO"], "priceMin": 300000, "priceMax": 1500000, "maxResults": 100 } ``` ##### Family homes, 3+ beds, larger sample ```json { "location": "Austin, TX", "homeTypes": ["SINGLE_FAMILY"], "bedsMin": 3, "maxResults": 300 } ``` ### Output - **Default dataset** — one row per normalized `listing`, each with its `intelligence` block. The dataset holds *only* listings, deliberately: Apify's dataset views project fields but don't filter rows by record type, so mixing record types into one dataset means every view shows blank rows for whichever type it wasn't built for (verified directly against a live run's `?view=` output, not assumed). Splitting the output this way keeps the "Listing intelligence" and "All fields" dataset views fully clean. - **`market_summary`** — one aggregate record per run (pricing, coverage, distributions, comparison quality, limitations), written to the run's **key-value store** under the key `MARKET_SUMMARY` instead of the dataset. Fetch it via the Actor run's output link, the Console's key-value store viewer, or `GET /v2/key-value-stores/{storeId}/records/MARKET_SUMMARY`. Abbreviated, real examples (pulled from a live run, not fabricated) are included with the repository in `examples/outputs`. ```json { "recordType": "listing", "zpid": "43885671", "address": "5005 Collins Ave APT 424, Miami Beach, FL 33140", "homeType": "CONDO", "price": 399000.0, "pricePerSqft": 295.56, "livingAreaSqft": 1350.0, "bedrooms": 2.0, "bathrooms": 2.0, "zestimate": 378900.0, "daysOnZillow": 17, "intelligence": { "pricePerSqftPercentile": 23.33, "pricePerSqftDeltaFromMedianPercent": -33.05, "pricePosition": "below_market", "zestimateDeltaPercent": 5.3, "daysOnMarketDeltaFromMedian": 0.0, "comparableSampleSize": 15, "comparableTier": "market", "confidence": "medium" } } ``` #### Field availability Zillow publishes different data on search results than on a property's own detail page. Nothing here is inferred or filled in — a field Zillow does not publish stays `null`. | Field | Search runs (`location` / `searchUrl`) | Single-property runs (`targetUrl`) | | --- | --- | --- | | Address, geo, price, beds, baths, sqft, home type, status, days on Zillow, broker, image | Always | Always | | `pricePerSqft` (derived) | Whenever price and living area are both published | Same | | `taxAssessedValue` | Nearly always | Always | | `lotAreaValue` / `lotAreaUnit` | About half of listings | When published | | `zestimate`, `rentZestimate` | About a third of listings | When published | | `priceChange`, `datePriceChanged`, `priceReduction` | About a quarter to a third of listings | When published | | `yearBuilt`, `monthlyHoaFee`, `propertyTaxRate` | **Never** — Zillow's search payload does not carry them | When published | | `intelligence` block | Always | Not applicable (sample of one) | Coverage percentages are what a real Miami Beach run returns; they vary by market. Every run's `market_summary` reports its own exact coverage, and each listing's `unavailableReasons` names the specific cause of any missing metric. ### Understanding the intelligence - **Price-per-sqft percentile** ranks the listing's midpoint within its comparable sample, 0–100. Lower means cheaper per square foot relative to comparables. - **Price-per-sqft delta from median** shows the dollar and percentage difference from that sample's median $/sqft. - **Price position** maps percentile bands to a readable label from `budget` to `premium`. - **Zestimate delta** is the list price versus Zillow's own automated estimate — positive means listed above Zestimate. This is computed directly from the listing's own data, so unlike the other intelligence fields it does **not** depend on comparable-sample size or confidence. - **Days-on-market delta** compares the listing's `daysOnZillow` to its comparable set's median. - **Comparable tier** says exactly how the sample was selected (see below). - **Confidence** summarizes sample size and coverage. Reason codes explain every label and every suppressed/unavailable metric — nothing is silently guessed. #### Methodology in brief Price-per-sqft percentile uses a tie-aware midpoint rank: `100 × (comparables below + 0.5 × comparables equal) / sample size`. Price-position bands are 0–20 budget, 20–40 below market, 40–60 market, 60–80 above market, and 80–100 premium. Price-relative metrics require at least 8 eligible comparables; below that, they're `null` with an `unavailableReasons` entry rather than a low-confidence guess. ### How comparable listings are selected The Actor tries the most specific viable segment first: **ZIP + home type + bedrooms → ZIP + home type → ZIP → the full collected market** Each tier needs at least 8 eligible listings (valid price and living area). The subject listing is excluded from its own sample. Confidence bands: `insufficient` (<8 comparables), `low` (8–14), `medium` (15–29), `high` (30+ with ≥70% price coverage and a segmented tier). #### Sample-selection bias The comparable population is *your collected run*, not the whole Zillow market. Your own `priceMin`/`priceMax`/`bedsMin`/`bathsMin`/`homeTypes` filters, `maxResults`, and Zillow's relevance-based result ordering all shape which listings end up in the comparable pool. A run filtered to `$300k–$500k` will not produce a percentile meaningful for a `$1.2M` property, and a `market`-tier fallback (broad, unsegmented) is a materially weaker signal than a `zip_type_beds`-tier match — that's exactly what `comparableTier` and `confidence` are for. Wider filters and larger `maxResults` generally produce a more representative comparable pool. ### Market summary The `market_summary` record (in the key-value store — see Output) is one aggregate view of the whole run: | Group | Contents | | --- | --- | | `market` | The location or search URL requested, plus every filter that shaped the sample — `homeTypesFilter`, `priceMinFilter`, `priceMaxFilter`, `bedsMinFilter`, `bathsMinFilter`, `maxResultsRequested`. | | `pricing` | `listingCount`; asking-price min/max/average/median; price-per-sqft min/max/average/median/P25/P75; median days on Zillow. | | `distributions` | Price-per-sqft quartile counts, home-type counts, bedroom counts, each with its own coverage percentage. | | `coverage` | Listings collected vs. analyzed, Zestimate coverage, duplicates removed, whether the sample was truncated, and a breakdown of why any listing was excluded from pricing. | | `comparisonQuality` | Overall confidence, comparable sample size, coverage rates, reason codes, and how many listings matched each comparable tier. | | `limitations` | Explicit coded caveats for the run — truncation, low coverage, small sample, unknown home types, missing living area. | **Every statistic states the sample it was computed from.** The three sample sizes are published alongside the numbers, because they differ on purpose: - `pricePerSqftSampleSize` — listings with both a price and a positive living area. - `priceSampleSize` — every listing with a price. A lot with no square footage still has a real asking price, so excluding it from a *price* median would bias that median toward listings that happen to publish square footage. - `daysOnZillowSampleSize` — listings that reported a days-on-market figure. Duplicates are removed before any of this is computed, and listings with a missing or non-positive price-per-sqft are excluded from the `*PricePerSqft` family with the reason recorded in `coverage.pricingExclusionReasons` rather than being silently counted as zero. Note that `averagePricePerSqft` is sensitive to outliers in luxury markets — a single ultra-premium listing can pull it well above `medianPricePerSqft`. Both are published so you can see the skew rather than having one of them chosen for you. ### Data quality and limitations - Results are a collected Zillow search sample, not complete market coverage. - **For-sale listings only** in this version; rentals are a planned fast-follow using the same comparable-set architecture. - Zillow caps a single search at roughly 820 reachable results — for larger markets, run multiple narrower searches (split by ZIP or price band) rather than one broad one. - Price-per-sqft and Zestimate coverage vary by listing; sparse or ultra-luxury listings often lack a Zestimate, and the Actor reports that explicitly rather than guessing. - Single-property (`targetUrl`) runs return the property's full observed detail data, but no comparable-set intelligence and no `market_summary` — there is nothing to rank a sample of one against. To benchmark a specific home, run a search over its ZIP and find it in the results. - Zillow's public page structure is theirs to change; provenance fields and null-handling reduce the impact but don't remove it. ### Use it from your own code Results are ordinary Apify datasets and key-value stores, so anything that speaks HTTP can read them. No proprietary dashboard, no export step. #### Python ```python from apify_client import ApifyClient client = ApifyClient("") run = client.actor("zapticx/zillow-market-intelligence").call( run_input={"location": "Miami Beach, FL", "maxResults": 100} ) for listing in client.dataset(run["defaultDatasetId"]).iterate_items(): print(listing["address"], listing["price"], listing["intelligence"]["pricePosition"]) summary = client.key_value_store(run["defaultKeyValueStoreId"]).get_record("MARKET_SUMMARY") print(summary["value"]["pricing"]["medianPricePerSqft"]) ``` #### JavaScript ```javascript import { ApifyClient } from 'apify-client'; const client = new ApifyClient({ token: '' }); const run = await client.actor('zapticx/zillow-market-intelligence').call({ location: 'Miami Beach, FL', maxResults: 100, }); const { items } = await client.dataset(run.defaultDatasetId).listItems(); const summary = await client.keyValueStore(run.defaultKeyValueStoreId).getRecord('MARKET_SUMMARY'); console.log(items.length, summary.value.pricing.medianPricePerSqft); ``` #### cURL ```bash curl -X POST "https://api.apify.com/v2/acts/zapticx~zillow-market-intelligence/run-sync-get-dataset-items?token=" -H "Content-Type: application/json" -d '{"location":"Miami Beach, FL","maxResults":100}' ``` The `market_summary` for any finished run is a single GET: ```bash curl "https://api.apify.com/v2/actor-runs//key-value-store/records/MARKET_SUMMARY?token=" ``` #### No-code Use the Apify integrations for Make, n8n, Zapier, Google Sheets, Airtable, Slack, or a plain webhook. Common patterns: a scheduled weekly market snapshot appended to a sheet, a webhook that alerts you when a listing appears below its comparable median, or a nightly pull into a BI tool. ### Performance Measured directly on the Apify platform, not estimated: - **100-listing default run:** ~9.5–10.2 seconds, ~52–60MB peak memory, zero retries, no proxy traffic needed (direct HTTP succeeds first in the large majority of runs). - **Full `maxResults: 820` run:** **21.3 seconds**, ~69MB peak memory. An earlier version of this run took 82 seconds — batching the dataset writes (instead of one network round-trip per listing) cut that by ~4×; see the Changelog. - **Zero-result searches** (e.g. an impossibly narrow price band) complete cleanly with a `market_summary` record and no crash. - Verified working: `location` input, direct `searchUrl` input, ZIP-code locations, and multiple `homeTypes` filters (`CONDO`, `SINGLE_FAMILY`). ### Pricing **Pay-per-event: $2.00 per 1,000 listings** ($0.002 per unique listing successfully written). That is the only charge — there is no Actor-start fee, no per-run minimum, and no charge for a run that returns nothing. `market_summary` lives in the key-value store, not the dataset, so it was never a chargeable dataset item in the first place — no separate charge, no ambiguity. Duplicates are removed before billing, so you are never charged twice for the same `zpid`. - **100 listings:** ~**$0.20** total - **300 listings:** ~**$0.60** total - **820 listings (max):** ~**$1.64** total This matches the pricing model of this account's `airbnb-market-intelligence` Actor and undercuts or matches raw-extraction-only competitors on the Zillow side of the Store ($0.0009–$0.0036 per listing), while being the only option in that comparison set that also computes price intelligence. ### Troubleshooting **Run fails immediately with a validation error.** Check that you provided exactly one of `location`, `searchUrl`, or `targetUrl`, and that `priceMax ≥ priceMin` if both are set. The error message names the exact field. **Run succeeds but returns 0 listings.** The location may be too narrow (a specific address instead of a city/ZIP/neighborhood) or your filters may be too restrictive for that area — try widening `priceMin`/`priceMax` or clearing `homeTypes`/`bedsMin`/`bathsMin`. **`comparableTier` is always `market` and `confidence` stays `low`/`insufficient`.** Your comparable pool isn't reaching the 8-listing floor for a tighter ZIP/type/bedroom segment — raise `maxResults`, widen filters, or expect a broad-market read for very narrow searches. **Run fails or returns unusually little data.** Zillow occasionally changes its page structure or serves a block page. The Actor retries automatically and treats direct HTTP as primary with Apify Proxy as a fallback; if it still fails, check the run log for the specific error — a `ParseError` means the page shape changed and needs a code update, while a `BlockedResponseError` means proxy traffic is warranted for that run. **Zestimate or price-per-sqft is `null` for most listings.** This is usually real: Zillow doesn't publish a Zestimate for every listing (ultra-luxury and some off-market-style listings often lack one), and price-per-sqft needs a living-area figure the listing may not expose. Check `unavailableReasons` on the listing for the specific cause rather than assuming a bug. ### FAQ #### Do I need to provide filters? No. `location` alone is enough — every other field has a sensible default and the Actor will return a broad market scan. #### What does a price-per-sqft percentile of 20 mean? It's a rank, not a percentage difference. A listing at the 20th percentile is cheaper per square foot than roughly 20% of its comparable set. Use `pricePerSqftDeltaFromMedianPercent` for the actual percentage difference from the median. #### Why is `zestimateDeltaPercent` null for some listings? Zillow doesn't publish a Zestimate for every listing — ultra-luxury and off-market-style listings often lack one. The Actor reports this explicitly via `unavailableReasons` rather than guessing. #### Why is my comparable sample size small? Small or very specific searches (a rare home type, a tight price band, a small ZIP) may not reach the 8-comparable floor for price-relative metrics. Widen `homeTypes`/`priceMin`/`priceMax` or drop `bedsMin`/`bathsMin`, or increase `maxResults`. #### Does this predict future value or investment returns? No. It reports observed public listing data and deterministic comparative metrics only — no appreciation, rental-yield, or return projections. #### Can I search for rentals? Not in this version. `listingType` currently only supports `for_sale`; rentals are a planned addition using the same architecture. ### Support Found a bug, hit a market that behaves oddly, or need a field this Actor does not yet extract? Open an issue on the Actor's **Issues** tab in Apify Console — that is the fastest route and it is monitored. Include the run ID; it carries the exact input, log, and output needed to diagnose the problem. Feature requests are welcome, particularly around rentals, sold comparables, and additional detail-page fields. # Actor input Schema ## `location` (type: `string`): The market to scrape. A city ("Miami Beach, FL"), a ZIP code ("33139"), a county, or a Zillow neighborhood ("Wynwood, Miami, FL"). This is the only field most runs need — everything below has a working default. Use exactly one of Location, Zillow search URL, or Single listing URL. ## `maxResults` (type: `integer`): How many unique listings to collect. Zillow caps a single search at roughly 820 results — for a bigger market, run several narrower searches split by ZIP or price band rather than one broad one. A larger sample also produces tighter comparable sets and higher confidence scores. ## `listingType` (type: `string`): For-sale listings only in this version. Rentals are a planned addition. ## `searchUrl` (type: `string`): A full zillow.com/homes/... search-results URL, copied from your browser after you have set up a search on Zillow. Use this when you need a filter this Actor does not expose. It replaces Location and the filter fields below. ## `targetUrl` (type: `string`): A single zillow.com/homedetails/... listing URL. Fetches just that one property — no search, no comparable-set intelligence, no market summary — and writes it as one target\_listing record. Adds three fields search results do not carry: year built, monthly HOA fee, and property tax rate. ## `homeTypes` (type: `array`): Restrict to these home types. Leave empty to include all of them. Narrowing to a single type usually raises comparable-set quality, because comparables are matched within a type. ## `priceMin` (type: `integer`): Minimum list price. Must be less than or equal to the maximum price. ## `priceMax` (type: `integer`): Maximum list price. Must be greater than or equal to the minimum price. ## `bedsMin` (type: `integer`): Only include listings with at least this many bedrooms. ## `bathsMin` (type: `integer`): Only include listings with at least this many bathrooms. ## `proxyConfiguration` (type: `object`): Apify Proxy is used only as a retry fallback — direct requests are attempted first and succeed in the large majority of runs. Leave this as it is unless a run reports blocked responses. ## Actor input object example ```json { "location": "Miami Beach, FL", "maxResults": 100, "listingType": "for_sale", "homeTypes": [], "proxyConfiguration": { "useApifyProxy": true } } ``` # Actor output Schema ## `results` (type: `string`): The default dataset — one row per normalized listing with its intelligence block. Use the 'Listing intelligence' or 'All fields' dataset view. ## `marketSummary` (type: `string`): Aggregate pricing, coverage, distributions, and limitations for the whole run — one record in the key-value store, not the dataset. # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "location": "Miami Beach, FL" }; // Run the Actor and wait for it to finish const run = await client.actor("zapticx/zillow-market-intelligence").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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "location": "Miami Beach, FL" } # Run the Actor and wait for it to finish run = client.actor("zapticx/zillow-market-intelligence").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 '{ "location": "Miami Beach, FL" }' | apify call zapticx/zillow-market-intelligence --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,zapticx/zillow-market-intelligence" } } } ``` 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 ` 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/gX2ifVYp6Q2ucoQHe/builds/3a4xZUAd4PxE96udR/openapi.json