# Zillow Scraper: Property Details, Zestimates & ZIP Listings (`humble-echidna/zillow-scraper`) Actor

Scrape Zillow property data with no login: give it Zillow links, ZPIDs or street addresses, or list every home for sale, for rent or recently sold in a ZIP code, city or state. Price, Zestimate, rent Zestimate, beds, baths, sqft, price and tax history, schools, photos, listing agent.

- **URL**: https://apify.com/humble-echidna/zillow-scraper.md
- **Developed by:** [Michael Costa](https://apify.com/humble-echidna) (community)
- **Categories:** Real estate, Lead generation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.65 / 1,000 homes

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

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

## How to integrate an Actor?

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

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

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

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

# README

### What does Zillow Scraper: Property Details, Zestimates & ZIP Listings do?

**Zillow Scraper** gets **Zillow property data** from the public property pages: give it **Zillow links, ZPIDs or
street addresses**, or a **ZIP code, city or state** to list every home for sale, for rent or recently sold
there. Each home comes back with the **price, Zestimate, rent Zestimate**, beds, baths, square feet, lot, year built,
listing facts, **price and tax history**, schools, photos and the **listing agent and brokerage**. **No login**, no
cookies, no account.

It is **not** a copy of Zillow's search filters: a location lists every home of the chosen type there, and you filter
by price or beds afterwards ([Limits](#limits)).

[Input fields](https://apify.com/humble-echidna/zillow-scraper/input-schema) ·
[API](https://apify.com/humble-echidna/zillow-scraper/api) ·
[Use it from Claude, ChatGPT or Cursor (MCP)](#can-i-use-zillow-scraper-from-an-ai-agent-mcp)

**Jump to:** [Monitor](#monitor-a-zip-code-get-only-new-zillow-listings-in-slack-email-or-a-webhook) ·
[Fields](#what-data-does-zillow-scraper-return) ·
[Price](#how-much-does-it-cost-to-scrape-zillow) ·
[How to use](#how-to-scrape-zillow-property-data) ·
[Input](#input) · [Output](#output) · [Switching](#switching-from-another-zillow-actor) ·
[AI agents (MCP)](#can-i-use-zillow-scraper-from-an-ai-agent-mcp) · [Limits](#limits) · [FAQ](#faq)

**Try it in one click:** the input comes pre-filled with one Worcester, MA home. That's 1 result, or about $0.0035
($3.40/1,000, plus $0.00005 for the run start). **Then replace it with what you actually want.**

### Monitor a ZIP code: get only new Zillow listings, in Slack, email or a webhook

With **Only homes not returned before** on, each run returns (and charges for) only the homes each location hasn't
returned in an earlier run. A run with nothing new costs only the $0.00005 start fee.

1. Put your ZIP codes or cities in **Locations** (`locations`), pick the **Listing type** (`listingType`), turn on
   **Only homes not returned before** (`"onlyNew": true`), and click **Start**. This first run returns every home
   there and is the baseline; set **Max results per run** if you only want a sample first.
2. Click **Save as a new task** (top right of the actor page). The memory is kept per location and listing type, so
   two tasks on the same ZIP (for sale and for rent, say) never hide each other's homes.
3. In Apify Console, open **Schedules**, click **Create new**, set how often in **Schedule setup** (for example daily
   at 07:00), then **Add** your task.
4. On the task, open the **Integrations** tab and pick where the new homes go:
   - **Slack**: click **Configure**, sign in, pick the workspace and channel, and the "run succeeded" event. A
     useful message: `{{resource.statusMessage}}` and a link,
     `<https://console.apify.com/storage/datasets/{{resource.defaultDatasetId}}|new listings>`.
   - **Gmail**: click **Connect with Google**, set the subject and body, and attach the dataset. It sends after each
     successful run.
   - **HTTP webhook**: event `ACTOR.RUN.SUCCEEDED`, your URL. Apify POSTs `{"eventType": ..., "resource": {...}}`;
     `resource.defaultDatasetId` is the run's dataset, and
     `GET https://api.apify.com/v2/datasets/<defaultDatasetId>/items?format=json` (with your API token) returns the
     new homes.

Apify's integrations fire after every successful run, including quiet ones: a quiet run's dataset is empty.

### What data does Zillow Scraper return?

| Field | Example | Notes |
|---|---|---|
| `zpid` | `56734390` | Zillow's property id; stable, use it to deduplicate |
| `homeStatus` | `FOR_SALE` | Also `FOR_RENT`, `PENDING`, `RECENTLY_SOLD`, `SOLD`, `OTHER` (off the market) |
| `streetAddress`, `city`, `state`, `zipcode` | `21 Dryden St`, `Worcester`, `MA`, `01605` | Plus `county`, `latitude`, `longitude` |
| `price` | `250000` | Asking price, monthly rent or sale price, by status; `null` when Zillow shows none |
| `zestimate`, `rentZestimate` | `250500`, `2341` | Zillow's value and rent estimates; `null` when Zillow has none |
| `bedrooms`, `bathrooms`, `livingArea` | `3`, `2`, `936` | Living area in square feet |
| `lotAreaValue`, `yearBuilt`, `homeType` | `4304`, `1890`, `SINGLE_FAMILY` | Lot in `lotAreaUnits` |
| `daysOnZillow`, `datePosted` | `105`, `2026-07-22T00:00:00Z` | For the current listing |
| `agentName`, `agentPhone`, `brokerName` | `Cynthia Rushton`, `508-769-9184`, `Central Mass Realty` | As the listing attributes it; plus `mlsId`, `mlsName` |
| `priceHistory` | `[{"date": "2026-07-20", "event": "Listed for sale", "price": 250000, ...}]` | Listing and sale events |
| `taxHistory` | `[{"year": 2025, "taxPaid": 3200, "value": 242600}, ...]` | Tax paid and assessed value by year |
| `photos` | `["https://photos.zillowstatic.com/fp/...-cc_ft_1536.jpg", ...]` | Largest size Zillow offers, in listing order |
| `facts` | `{"heating": ["Steam", "Natural Gas"], ...}` | Heating, cooling, parking, appliances, HOA, taxes and the rest that's filled in |

Every result has the same fields; the full list is under [Output](#output).

### How much does it cost to scrape Zillow?

You pay per home: **$3.40 per 1,000 homes** on Apify's Free plan, **$2.85** on Starter, **$2.25** on Scale and
**$1.65** on Business, plus $0.00005 each time a run starts.

- **The pre-filled example:** 1 home = about $0.0035 with the start fee.
- **A month, for example:** a daily schedule on 5 ZIP codes with **Only homes not returned before**, about 40 new
  listings a day, is 1,200 homes ≈ **$4.08** on Free, **$3.42** on Starter.
- **Caps:** **Max results per run** in the input, and **Maximum cost per run** in the run options. The run stops
  cleanly at whichever comes first; it stops opening pages as soon as the limit is covered, so a capped run is also a
  fast one.

**Never charged:** inputs that fail, homes whose listing has moved to another type though Zillow's sitemap still lists
them (in one ZIP code, 20 of 64 "for sale" homes were pending or sold; turn on **Include pending homes** to get the
pending ones), homes already returned for another input in the same run, and homes an earlier run
returned when **Only homes not returned before** is on.

### How to scrape Zillow property data

1. Open Zillow Scraper and click **Try for free** (or **Start** if you're signed in).
2. Paste Zillow links, ZPIDs or addresses into **Properties**, or ZIP codes and cities into **Locations** (or both).
3. For locations, pick the **Listing type**: for sale, for rent or recently sold.
4. Click **Start**, then open the **Output** tab and export as JSON, CSV or Excel.

### Example: one home in Worcester, MA

The pre-filled input:

```json
{"properties": ["https://www.zillow.com/homedetails/21-Dryden-St-Worcester-MA-01605/56734390_zpid/"]}
```

It returned 1 result (real output from a local run on 2026-11-04; long lists and text shortened):

```json
{
  "zpid": "56734390",
  "url": "https://www.zillow.com/homedetails/21-Dryden-St-Worcester-MA-01605/56734390_zpid/",
  "homeStatus": "FOR_SALE",
  "streetAddress": "21 Dryden St",
  "city": "Worcester",
  "state": "MA",
  "zipcode": "01605",
  "county": "Worcester County",
  "latitude": 42.284657,
  "longitude": -71.80394,
  "price": 250000,
  "currency": "USD",
  "zestimate": 250500,
  "rentZestimate": 2341,
  "bedrooms": 3,
  "bathrooms": 2,
  "livingArea": 936,
  "lotAreaValue": 4304,
  "lotAreaUnits": "Square Feet",
  "yearBuilt": 1890,
  "homeType": "SINGLE_FAMILY",
  "propertyTaxRate": 1.22,
  "daysOnZillow": 105,
  "datePosted": "2026-07-22T00:00:00Z",
  "pageViewCount": 1203,
  "favoriteCount": 50,
  "description": "Great opportunity to finish what the owners started! Open Living room & dining room, new kitchen and...",
  "photoCount": 9,
  "photos": ["https://photos.zillowstatic.com/fp/a5fa4cee093978b339a6ce3d01f17bc4-cc_ft_1536.jpg", "..."],
  "mlsId": "73552071",
  "mlsName": "MLS PIN",
  "agentName": "Cynthia Rushton",
  "agentPhone": "508-769-9184",
  "brokerName": "Central Mass Realty",
  "parcelId": "WORCM09B028L00011",
  "walkScore": 63,
  "transitScore": 38,
  "bikeScore": 18,
  "facts": {"architecturalStyle": "Colonial", "heating": ["Steam", "Natural Gas"], "flooring": ["Wood", "Tile", "Vinyl"]},
  "priceHistory": [{"date": "2026-07-20", "event": "Listed for sale", "price": 250000, "pricePerSquareFoot": 267, "source": "MLS PIN"}],
  "taxHistory": [{"year": 2025, "taxPaid": 3200, "value": 242600}, {"year": 2024, "taxPaid": 3064, "value": 222800}],
  "schools": [{"name": "Francis J McGrath Elementary School", "rating": 5, "grades": "PK-6", "distance": 0.5, "link": "https://www.greatschools.org/massachusetts/worcester/1862-Francis-J-Mcgrath-Elementary-School/"}],
  "input": "https://www.zillow.com/homedetails/21-Dryden-St-Worcester-MA-01605/56734390_zpid/",
  "scrapedAt": "2026-11-04T20:07:12.006552Z"
}
```

### Input

| Field | What it does |
|---|---|
| **Properties** (`properties`) | Zillow property links, ZPIDs or US street addresses, one per line. One result each, whatever the home's status. |
| **Locations** (`locations`) | ZIP codes (`01605`), cities (`Austin, TX`), state codes (`VT`) or Zillow place/search links, one per line. Every home of the listing type there. |
| Listing type (`listingType`) | For Locations: `forSale` (default), `forRent` or `recentlySold`. |
| Include pending homes (`includePending`) | With `forSale`: also return homes under contract, instead of leaving them out. |
| Only homes not returned before (`onlyNew`) | For Locations on a schedule: skip homes an earlier run returned. |
| Max results per run (`maxResults`) | Cap the total number of homes across all lines; locations share it. |

```json
{
  "properties": ["56734390", "27952 Doreen Dr, Sun City, CA 92586"],
  "locations": ["01605", "Austin, TX"],
  "listingType": "forSale",
  "maxResults": 200
}
```

### Output

One row per home, every field on every row; fields Zillow doesn't show for a home are `null` (or an empty list).
The example above shows them all. `zpid` is stable across runs and status changes, so you can use it to deduplicate.
`input` is the line the home came from. The run's `RUN_STATS` record lists every line, how many homes it matched and
returned, and anything that failed, with the reason.

### Switching from another Zillow actor?

Most Zillow actors take property links, ZPIDs, addresses, search URLs or ZIP codes. Here's where each goes:

| What you had | Put it here |
|---|---|
| Property links (`startUrls`) or ZPIDs | **Properties** (`properties`), one per line; links, ZPIDs and addresses can be mixed |
| Addresses | **Properties** too: Zillow's own address search finds the home |
| ZIP codes (`zipCodes`) | **Locations** (`locations`) |
| A Zillow search URL (`searchUrls`) | **Locations**: paste it and the place is read from it (`/austin-tx/`, or the search term in the link); the link's filters aren't applied |
| A for sale / for rent / sold switch | **Listing type** (`listingType`); pending homes with **Include pending homes** (`includePending`) |
| A "fetch details" option or add-on event | Not needed: every home comes with full details |
| Price, beds or other search filters | Filter the results afterwards ([why](#limits)) |

What's different in the output: one flat row per home, with the main numbers as top-level columns
(`price`, `zestimate`, `bedrooms`, `livingArea`, ...) and the lists (`photos`, `priceHistory`, `taxHistory`, `schools`)
and `facts` as nested values.

### Run it on a schedule, or from your own code

1. Save your input as a [task](https://docs.apify.com/platform/actors/running/tasks) (**Save as a new task**, top right
   of the actor page) and add it to a [schedule](https://docs.apify.com/platform/schedules) (Console → Schedules →
   **Create new**).
2. Collect results: download the dataset as JSON, CSV or Excel; fetch the latest run's results from the
   [API](https://apify.com/humble-echidna/zillow-scraper/api)
   (`GET https://api.apify.com/v2/actor-tasks/<task id>/runs/last/dataset/items?status=SUCCEEDED&format=csv`, with
   your API token); let a [webhook](https://docs.apify.com/platform/integrations/webhooks) tell your system when a
   run succeeds; or connect it to Make, Zapier or n8n through
   [Apify's integrations](https://docs.apify.com/platform/integrations).

#### Can I use Zillow Scraper from an AI agent (MCP)?

Yes, through [Apify's MCP server](https://docs.apify.com/platform/integrations/mcp), from Claude, ChatGPT, Cursor or
any other MCP client. Add this to your client's MCP configuration (or let the agent find it with the server's actor
search); your client signs you in to Apify:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=humble-echidna/zillow-scraper"
    }
  }
}
```

To use an [Apify API token](https://console.apify.com/settings/integrations) instead of signing in, add
`"headers": {"Authorization": "Bearer <APIFY_TOKEN>"}` next to `url`.

An agent looking up one home passes `{"properties": ["21 Dryden St, Worcester, MA 01605"]}`; for a market sample,
`{"locations": ["01605"], "maxResults": 20}`.

### Who it's for

Real-estate investors and wholesalers pulling comps and new listings in their ZIP codes, agents and brokers watching
a farm area, property managers checking rents and Zestimates, and analysts or AI agents that need fresh Zillow numbers
for a list of addresses without copying them by hand.

### Why this one?

- **Full details on every home, one price.** Price, Zestimate, rent Zestimate, facts, price and tax history,
  schools, photos and the listing agent come with every result; there's no separate "details" event or add-on.
- **Addresses, links, ZPIDs and places in one run.** Mix them; a home that comes up twice is returned once.
- **New listings on a schedule.** **Only homes not returned before** turns a ZIP code into a daily new-listings feed;
  quiet runs cost the start fee.
- **Stale listings left out free.** A location run checks each home's live status and skips (and doesn't charge
  for) homes that have moved on though Zillow's sitemap still lists them. With **Only homes not returned before** on,
  they're not opened again for 7 days.
- **Reliable.** One failing line never affects the others. A visitor Zillow turns away is replaced by a new one, and
  a run refused everywhere stops early with the reason instead of hanging. The run log and `RUN_STATS` say exactly
  which line had a problem and why.

### Limits

- **No Zillow search filters.** Zillow's robots.txt disallows its search pages and search API, so this actor
  doesn't load them. A location lists homes from Zillow's sitemaps, which name the place in each home's link but
  nothing else; filter by price, beds or type in the results (or with Dataset Transformer, below).
- **Locations follow the link's address.** A home is in a city or ZIP when Zillow's link for it says so; a few links
  name a neighbouring city. ZIP codes are the most exact.
- **Sitemap freshness.** Zillow updates its sitemaps through the day; a listing posted in the last hours may not be
  in them yet, and the next scheduled run picks it up.
- **Recently sold** covers Zillow's sitemap of sold homes, which holds several years; check `lastSoldDate` and
  `priceHistory` for the sale you want.
- **What logged-out visitors see.** No saved homes, no owner views, no data behind a Zillow sign-in.
- **Pending homes only with for sale.** Zillow lists them with its for-sale homes, so they come from a `forSale` run
  with **Include pending homes** on; there's no pending-only list.
- **US only**, as Zillow is.

### FAQ

#### Is it legal to scrape Zillow?

This actor reads only public pages that anyone can open without signing in: property pages and the sitemaps Zillow
publishes for search engines. It follows Zillow's robots.txt (property pages and sitemaps are allowed there; search
pages, the search API and GraphQL are not, and it never requests them), identifies itself with its own User-Agent,
and never logs in, so it accepts no Zillow terms on your behalf. Zillow's bot protection turns away datacenter IP
addresses, so property pages are read through residential ones, at most three pages a second per run. Zillow's Terms
of Use forbid automated queries and
scraping, and much of the listing data is copyrighted by the MLS that supplied it and licensed for consumers'
personal, non-commercial use; a US federal court held in 2024 (Meta v. Bright Data) that a site's terms didn't bind a
scraper of public data that never logged in, but the law differs by country and by use. Results include listing
agents' names and business phone numbers as the listings show them. How you use the data is up to you and the laws
that apply to you. Zillow or an agent who wants something left out can open an issue.

#### Why did a line return nothing, or fewer homes than expected?

The usual reasons: the link isn't a property page (search links go in **Locations**), the address isn't one Zillow
knows, the place has no homes of that listing type in Zillow's sitemaps, homes had moved on to another status, or
**Only homes not returned before** skipped the ones you already have. The run log and `RUN_STATS` name the line and
the reason, and every other line is unaffected. If Zillow turned away every visitor, the lines fail free; run it
again later. Please open an issue with the input you used if it keeps happening.

#### Can I get only new results since my last run?

Yes, for locations: turn on **Only homes not returned before**
([how](#monitor-a-zip-code-get-only-new-zillow-listings-in-slack-email-or-a-webhook)). Properties lines are always
returned.

#### How is this different from Zillow's official API?

Zillow's data APIs (through Bridge Interactive) are for approved partners, mostly MLS members and brokerages, under
their own agreements. This actor needs no approval and works for any home with a public Zillow page, but only with
what logged-out visitors can see.

### Related actors

| Actor | Use it when |
|---|---|
| [Dataset Transformer](https://apify.com/humble-echidna/dataset-transform) | You want the homes filtered by price or beds, renamed or flattened into your own CSV or Excel layout |
| [Dataset Diff](https://apify.com/humble-echidna/dataset-diff) | You want to see which prices or statuses changed between two runs |

### Feedback and support

Found a bug, or need a field that isn't here? Open an issue on the **Issues** tab with the input you used.

### Versions

Current version: **0.1**. See the Changelog tab for what changed in each version.

# Changelog

This Actor's version history is a separate document: https://apify.com/humble-echidna/zillow-scraper/changelog.md

# Actor input Schema

## `properties` (type: `array`):

Homes to look up, one per line: a Zillow property link (https://www.zillow.com/homedetails/21-Dryden-St-Worcester-MA-01605/56734390_zpid/), a ZPID (56734390), or a US street address (21 Dryden St, Worcester, MA 01605). One result each with full details, whatever the home's status (for sale, for rent, sold, off the market). Search page links go in Locations. Can be combined with Locations.

## `locations` (type: `array`):

Places to list homes in, one per line: a 5-digit ZIP code (01605), a city with its state ('Austin, TX'), a two-letter state code (VT), or a Zillow place or search link (https://www.zillow.com/austin-tx/), which is read only for its place name. Every home of the chosen Listing type in that place is returned with the same full details as Properties, the most recently updated first. Zillow's price, bed and other search filters aren't applied; filter the results afterwards. Empty by default.

## `listingType` (type: `string`):

Which homes Locations lists: `forSale` (by agent or owner, new construction, auctions), `forRent` or `recentlySold`. Ignored for Properties lines, which are returned whatever their status. Default `forSale`.

## `includePending` (type: `boolean`):

With Listing type `forSale`: also return homes that are pending or under contract (`homeStatus` PENDING) instead of leaving them out. Ignored for other listing types. Default off.

## `onlyNew` (type: `boolean`):

For a scheduled run: return only the homes each Locations line hasn't returned in an earlier run, so a daily schedule on a ZIP code gives the day's new listings. Remembered per location and listing type in a store in your own Apify account. Default off.

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

Stop after this many homes in total, e.g. 50. Minimum 1; leave empty (the default) for no limit. Locations share it evenly. The run also stops cleanly at the maximum cost per run you set in the run options, whichever comes first.

## Actor input object example

```json
{
  "properties": [
    "https://www.zillow.com/homedetails/21-Dryden-St-Worcester-MA-01605/56734390_zpid/"
  ],
  "listingType": "forSale",
  "includePending": false,
  "onlyNew": false
}
```

# Actor output Schema

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

No description

## `runStats` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "properties": [
        "https://www.zillow.com/homedetails/21-Dryden-St-Worcester-MA-01605/56734390_zpid/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("humble-echidna/zillow-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 = { "properties": ["https://www.zillow.com/homedetails/21-Dryden-St-Worcester-MA-01605/56734390_zpid/"] }

# Run the Actor and wait for it to finish
run = client.actor("humble-echidna/zillow-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 '{
  "properties": [
    "https://www.zillow.com/homedetails/21-Dryden-St-Worcester-MA-01605/56734390_zpid/"
  ]
}' |
apify call humble-echidna/zillow-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,humble-echidna/zillow-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/f4LIFo74jOjW5Hxc7/builds/jyEOthl38x9l3PW2D/openapi.json
