# Realtor.com Listing & Property Detail Extractor (`nimbryxo-studio/realtor-com-listing-and-property-detail-extractor`) Actor

Search Realtor.com for-sale, for-rent, or recently-sold listings by city, or pull full detail pages with agent contacts, nearby schools, tax and price history, and flood/wildfire/noise risk scores.

- **URL**: https://apify.com/nimbryxo-studio/realtor-com-listing-and-property-detail-extractor.md
- **Developed by:** [Nimbryxo-studio](https://apify.com/nimbryxo-studio) (community)
- **Categories:** Real estate, Lead generation, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Realtor.com Property & Agent Scraper

Turn Realtor.com into structured data. Search active, rental, sold, pending, contingent, coming-soon, off-market or new-construction listings by city, ZIP, street address, map radius or GeoJSON polygon; apply real filters; and pull the full property record — MLS number, HOA, mortgage estimate, assigned schools, open houses, tours, photo tags, tax and price history, risk scores and agent contacts. Switch one field to collect real-estate agent directory records, including profile phone numbers.

No account, cookies, API key or proxy setup is required.

### What this actor does

- **Eight listing statuses** — `BUY` (for sale), `RENT`, `SOLD`, `PENDING`, `CONTINGENT`, `COMING_SOON`, `OFF_MARKET` and `READY_TO_BUILD`.
- **Five ways to target** — free-form location (city, ZIP, neighborhood, county), street address, a map point with a mile radius, a GeoJSON polygon, or Realtor.com URLs.
- **Real server-side filters** — beds, baths, price, living area, lot size, year built, property type, keywords, photos-only, coming-soon, open-house dates and listing/sold dates.
- **Full detail records** — one detail lookup per property adds the marketing description, HOA fee, mortgage estimate, assigned and nearby schools, open houses, virtual tours, photo tags, categorized features, tax/price history, parcel ids and expanded agent contacts.
- **Agent directory** — search agents by name, city/state or ZIP; returns name, office, profile phones, license, bio, languages, designations, avatar and public profile URL.
- **Sorted and paginated deeply** — newest, price, size or bedroom ordering, up to 10,000 records per run (the source's addressable search window).
- **Honest output** — a field the source does not publish for a listing is omitted, never guessed or filled with a sentinel. Zero placeholder prices from public records are removed rather than emitted.

### Listing statuses

| Mode | What it returns |
|---|---|
| `BUY` | Active for-sale listings |
| `RENT` | Active rental listings |
| `SOLD` | Recently sold properties with sale date and, where published, sale price |
| `PENDING` | For-sale listings with an accepted offer |
| `CONTINGENT` | For-sale listings still subject to a contingency |
| `COMING_SOON` | Not-yet-active listings announced ahead of the market |
| `OFF_MARKET` | Delisted / off-market listings |
| `READY_TO_BUILD` | New-construction and build-ready listings |

`PENDING`, `CONTINGENT` and `COMING_SOON` come back with `status: for_sale` and the matching `flags.isPending` / `flags.isContingent` / `flags.isComingSoon` set, because that is how the source models them. The same coming-soon filter is available as `comingSoonOnly` on the other for-sale modes.

### Filters

| Filter | Applies to |
|---|---|
| `bedsMin` / `bedsMax` | Bedroom range |
| `bathsMin` / `bathsMax` | Bathroom range |
| `priceMin` / `priceMax` | List price range (USD) |
| `sqftMin` / `sqftMax` | Living area range |
| `lotSqftMin` / `lotSqftMax` | Lot size range |
| `yearBuiltMin` / `yearBuiltMax` | Construction year range |
| `propertyTypes` | One or more of Realtor.com's 20 property types |
| `keywords` | Free-text terms such as `pool`, `waterfront`, `garage` |
| `hasPhotos` | Exclude listings without photos |
| `comingSoonOnly` | Only coming-soon listings in the for-sale modes |
| `openHouseFrom` / `openHouseTo` | Listings with an open house in the date window |
| `listedSince` | Listings added on or after a date (delta monitoring) |
| `soldSince` | In `SOLD` mode, sales on or after a date |
| `latitude` + `longitude` + `radiusMiles` | Radius search around a map point |
| `boundary` | GeoJSON Polygon search area (longitude/latitude rings) |
| `sortBy` | Relevance, newest, price low/high, largest living area or most bedrooms |

Filters are sent to Realtor.com and then verified on every returned record, so a filter cannot silently pass through unfiltered rows.

### Output per property

Identity

- `recordType` — always `property`
- `url`, `id`, `listingId`, `permalink`
- `mlsId`, `mlsSource`, `mlsType`, `mlsStatus`
- `parcelId` plus `taxRecord.clId`, `.publicRecordId`, `.lastUpdateDate`, `.apn`, `.taxParcelId`
- `status`

Pricing

- `listPrice`, `listPriceMin`, `listPriceMax` (range-priced new builds have no single price)
- `pricePerSqft` — from the source, or computed from list price and living area
- `priceReduced` — reduction amount
- `lastSoldPrice`, `soldOn`
- `estimatedValue`, and `estimates[]` with `.estimate`, `.estimateLow`, `.estimateHigh`, `.date`, `.source`, `.sourceType` (multiple valuation providers when available)
- `mortgage.monthlyPayment`, `.downPayment`, `.loanAmount`
- `hoaFee`

Property facts

- `beds`, `baths`, `bathsFull`, `bathsHalf`
- `sqft`, `lotSqft`, `yearBuilt`, `yearRenovated`
- `garage`, `garageType`, `stories`, `rooms`, `units`
- `type`, `subType`, `name` (community/building name)
- `listDate`, `pendingDate`, `lastStatusChangeDate`, `lastUpdateDate`
- `daysOnMarket` — source value, or derived from the list date (and the sale date for sold records)

Location

- `address.street`, `.city`, `.state`, `.postalCode`, `.county`, `.countyFips`, `.neighborhoods`
- `coordinates.lat`, `.lng`

Media

- `photos` — photo URLs
- `photoTags` — `[{ url, tags: ["kitchen", "exterior", …] }]`
- `virtualTours` — `[{ href, type }]`

Flags

- `flags.isNewListing`, `.isPriceReduced`, `.isForeclosure`, `.isNewConstruction`, `.isPending`, `.isContingent`, `.isComingSoon`

Detail sections (when `scrapeDetails` is on and the source publishes them)

- `text` — full marketing description
- `features` — cooling, heating, exterior, roofing, construction, fireplace, pool, zoning, styles, garage type
- `tags` — source amenity tags
- `details` — categorized feature lists, `[{ category, parentCategory, items }]`
- `petPolicy`, `unitDetails`
- `nearbySchools` — name, rating, distance, grades, type, levels, student count, `assigned`
- `assignedSchools` — the assigned public schools for the address
- `openHouses` — start, end, description, methods, time zone, DST
- `local.flood`, `.noise`, `.wildfire` — risk scores, severity, FEMA zone, noise categories
- `history` — listing/sale events with date, event, price and price per sqft; zero placeholder prices are omitted per row
- `taxHistory` — year, tax, assessed and market values (total/land/building); zero placeholders are omitted
- `agents` — name, email, phone, office, office phone, office email, type, license, NRDS id, fulfillment id, broker
- `branding`, `products`, `leadAttributes`, `otherListings`

Every record ends with `scrapedAt` (ISO timestamp).

### Output per agent

- `recordType` — always `agent`
- `agentId`, `fulfillmentId`
- `name`, `profileUrl`, `website`
- `officeName`, `licenseNumber`
- `phone`, `phones[]` — profile phone numbers with their `type` (when Realtor.com publishes them and `scrapeDetails` is on)
- `officePhone`, `officePhones[]` — office phone numbers from the same profile
- `bio`, `languages`, `designations`
- `avatarUrl`
- `searchLocation` — the agent-name/city/ZIP query that produced the record
- `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | Select | `BUY` | Listing status: `BUY`, `RENT`, `SOLD`, `PENDING`, `CONTINGENT`, `OFF_MARKET`, `READY_TO_BUILD` |
| `recordType` | Select | `PROPERTIES` | Collect property listings or agent directory records |
| `search` | String | - | City/state, ZIP, neighborhood, county or street address. In agent mode: city/state or ZIP |
| `agentName` | String | - | Agent or team name (agent mode) |
| `startUrls` | Array | `[]` | Realtor.com detail or search-result URLs |
| `maxItems` | Integer | `100` | Maximum records to emit (1-10,000) |
| `endPage` | Integer | `50` | Maximum result pages per search (200 properties per page; 50 reaches 10,000) |
| `scrapeDetails` | Boolean | `true` | Fetch each property's full detail record; in agent mode, fetch profile phones |
| `bedsMin`, `bedsMax` | Integer | - | Bedroom range |
| `bathsMin`, `bathsMax` | Integer | - | Bathroom range |
| `priceMin`, `priceMax` | Integer | - | List price range |
| `sqftMin`, `sqftMax` | Integer | - | Living area range |
| `lotSqftMin`, `lotSqftMax` | Integer | - | Lot size range |
| `yearBuiltMin`, `yearBuiltMax` | Integer | - | Construction year range |
| `propertyTypes` | Multi-select | `[]` | One or more property types |
| `keywords` | String list | `[]` | Free-text keywords |
| `hasPhotos` | Boolean | `false` | Only listings with photos |
| `comingSoonOnly` | Boolean | `false` | Only coming-soon listings in for-sale modes |
| `sortBy` | Select | `relevant` | `relevant`, `newest`, `price_low`, `price_high`, `sqft_high`, `beds_high` |
| `listedSince` | Date | - | Listings added on/after `YYYY-MM-DD` |
| `soldSince` | Date | - | Sales on/after `YYYY-MM-DD` (`SOLD` mode) |
| `openHouseFrom`, `openHouseTo` | Date | - | Open-house date window |
| `latitude`, `longitude` | Number | - | Map point for a radius search |
| `radiusMiles` | Integer | - | Radius around the map point (1-100 miles) |
| `boundary` | Object | - | GeoJSON Polygon: `{"type":"Polygon","coordinates":[[[lon,lat],...]]}` |

At least one of `search`, `startUrls`, a complete latitude/longitude/radius point, or a `boundary` polygon is required for property mode. Agent mode needs `agentName` or `search`.

#### Example: active listings in a city

```json
{
    "mode": "BUY",
    "search": "Houston, TX",
    "maxItems": 100,
    "scrapeDetails": true
}
```

#### Example: comparable sales

```json
{
    "mode": "SOLD",
    "search": "Denver, CO",
    "soldSince": "2026-01-01",
    "maxItems": 50,
    "scrapeDetails": true
}
```

#### Example: filtered search with open houses

```json
{
    "mode": "BUY",
    "search": "Austin, TX",
    "bedsMin": 3,
    "priceMax": 750000,
    "propertyTypes": ["single_family"],
    "openHouseFrom": "2026-11-01",
    "openHouseTo": "2026-11-30",
    "sortBy": "newest",
    "maxItems": 25
}
```

#### Example: radius search around coordinates

```json
{
    "mode": "BUY",
    "latitude": 29.76,
    "longitude": -95.36,
    "radiusMiles": 5,
    "sqftMin": 1500,
    "maxItems": 50
}
```

#### Example: coming-soon listings

```json
{
    "mode": "COMING_SOON",
    "search": "Atlanta, GA",
    "maxItems": 50,
    "scrapeDetails": false
}
```

`comingSoonOnly: true` applies the same filter inside `BUY`, `PENDING` or `CONTINGENT` mode.

#### Example: polygon search area

```json
{
    "mode": "BUY",
    "boundary": {
        "type": "Polygon",
        "coordinates": [
            [[-95.6, 29.6], [-95.0, 29.6], [-95.0, 30.1], [-95.6, 30.1], [-95.6, 29.6]]
        ]
    },
    "maxItems": 50,
    "scrapeDetails": false
}
```

Rings may be open; the actor closes them automatically. Coordinates are `[longitude, latitude]`.

#### Example: agent directory by city or ZIP

```json
{
    "recordType": "AGENTS",
    "search": "Houston, TX",
    "maxItems": 100
}
```

```json
{
    "recordType": "AGENTS",
    "agentName": "Pedro Casanova",
    "maxItems": 25
}
```

#### Example: direct property URLs

```json
{
    "startUrls": [
        { "url": "https://www.realtor.com/realestateandhomes-detail/1802-Hamlin-Valley-Dr_Houston_TX_77090_M80144-71467" }
    ],
    "scrapeDetails": true
}
```

Search-result URLs work too; their location, status and page are reused:

```json
{
    "startUrls": [
        { "url": "https://www.realtor.com/realestateandhomes-search/Houston_TX/pg-2" }
    ],
    "maxItems": 20
}
```

### Use cases

- **Comparable-sales research** — pull `SOLD` records by ZIP or neighborhood with sale dates, assessed values and price per sqft.
- **Buyer shortlists** — check flood, wildfire and noise scores, assigned schools, HOA and monthly mortgage estimates before a showing.
- **Open-house planning** — filter by open-house dates and get start/end times, methods and time zone in one dataset.
- **Investor screening** — compare list price, tax history and automated valuations to spot under- or over-assessed properties.
- **Rental tracking** — run `RENT` on a schedule and use `listedSince` or `sortBy: newest` for deltas.
- **Agent and brokerage mapping** — collect agent names, offices, licenses, languages and profile links for a market.
- **Listing monitoring** — schedule a run with `listedSince` to pick up new inventory without re-scraping everything.

### Data source and reliability

The actor reads Realtor.com's public web endpoints. It does not log in, and it does not need cookies, browser automation or a paid proxy. Detail enrichment costs one request per property (and one per agent in agent mode); turn `scrapeDetails` off when search-level fields are enough.

### Limits and FAQ

**How many results can one search return?**
Up to 10,000 per run, which is Realtor.com's own addressable search window (200 per request, offset up to 10,000). The result total can be larger, but only the first 10,000 rows of one search are reachable. To go deeper, split the market with filters (price bands, property type, ZIP codes or smaller map radii) and run each slice.

**Do I need a Realtor.com account or API key?**
No. Both property and agent searches use public data and run without credentials.

**Why is `lastSoldPrice` empty for some sold properties?**
Some US states do not disclose sale prices. The sale date and history events are still returned when published; price fields are omitted rather than guessed or filled with the `0` placeholder that public records sometimes carry. The same rule applies inside `history` and `taxHistory` rows.

**Why are some detail fields missing on a property?**
Sections such as HOA, tax history, assigned schools, open houses, tours, risk scores and mortgage estimates exist only when Realtor.com publishes them for that listing. New construction and off-market properties often have fewer sections.

**What is the difference between `PENDING` and `CONTINGENT`?**
Both are for-sale listings under contract; the source marks them with separate flags, which the actor filters on and exposes as `flags.isPending` and `flags.isContingent`.

**Can I scrape coming-soon listings?**
Yes. Use `mode: COMING_SOON` or set `comingSoonOnly: true` in a for-sale mode. The actor applies Realtor.com's coming-soon filter, verifies `flags.isComingSoon` on each record and exposes the flag in the output.

**How is `daysOnMarket` calculated?**
It uses the source value when present. Otherwise it is the number of days between the list date and today, or between the list date and the sale date for sold records. It is always non-negative.

**Why did I get fewer records than `maxItems`?**
The location or filter combination may have fewer matches, the result set may have hit the source's 10,000-listing ceiling, or the pages ran out. Narrow or broaden the search accordingly.

**Can I mix a location search and direct URLs?**
Yes. Direct detail URLs are resolved individually and de-duplicated against the search results by property id.

**Does agent mode return phone numbers and email addresses?**
Profile phone numbers are returned when Realtor.com publishes them and `scrapeDetails` is on, together with the office phone when available. Agent emails are not exposed by the public agent profile endpoint, so they are never fabricated; property advertiser emails are returned when the listing publishes them. Agent records always include a public profile URL so missing contact details can be checked at the source.

**Is this affiliated with Realtor.com?**
No. It is an independent tool that reads publicly available Realtor.com pages and endpoints; it is not operated or endorsed by Realtor.com.

# Actor input Schema

## `mode` (type: `string`):

Property status to search. `BUY` is active for-sale, `RENT` is for-rent, `SOLD` is recently sold, `PENDING`/`CONTINGENT` are under contract, `COMING_SOON` is not-yet-active inventory, `OFF_MARKET` is delisted and `READY_TO_BUILD` is new construction. Used in property mode; ignored in agent mode.

## `recordType` (type: `string`):

Collect property listings or real-estate agent directory records.

## `search` (type: `string`):

City and state (`Houston, TX`), ZIP code (`77002`), neighborhood, county or a street address (`16142 Maladi Dr`). In agent mode this may be a city/state or ZIP.

## `agentName` (type: `string`):

Agent or team name to search in agent mode, e.g. `Pedro Casanova`. Leave empty to search agents by the location above.

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

Realtor.com property detail URLs or search-result URLs. Detail URLs are resolved directly; search URLs reuse their location, mode and page.

## `maxItems` (type: `integer`):

Maximum property or agent records to emit (1-10000). Property searches are limited by the source to 10,000 addressable rows per search.

## `endPage` (type: `integer`):

Maximum GraphQL result pages per search. Each page holds up to 200 properties; set 50 to reach the 10,000-row search cap. Agents use their own page size.

## `scrapeDetails` (type: `boolean`):

Fetch each property's full detail record: description, HOA, mortgage estimate, assigned schools, open houses, tours, photo tags, tax and price history, risk scores and extra agent contacts. In agent mode it also fetches each agent's profile phone numbers.

## `bedsMin` (type: `integer`):

Minimum bedrooms. Applied server-side, then verified on each record.

## `bedsMax` (type: `integer`):

Maximum bedrooms.

## `bathsMin` (type: `integer`):

Minimum bathrooms.

## `bathsMax` (type: `integer`):

Maximum bathrooms.

## `priceMin` (type: `integer`):

Minimum list price in US dollars.

## `priceMax` (type: `integer`):

Maximum list price in US dollars.

## `sqftMin` (type: `integer`):

Minimum living area in square feet.

## `sqftMax` (type: `integer`):

Maximum living area in square feet.

## `lotSqftMin` (type: `integer`):

Minimum lot size in square feet.

## `lotSqftMax` (type: `integer`):

Maximum lot size in square feet.

## `yearBuiltMin` (type: `integer`):

Minimum construction year.

## `yearBuiltMax` (type: `integer`):

Maximum construction year.

## `propertyTypes` (type: `array`):

Limit results to one or more Realtor.com property types.

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

Free-text keywords matched by Realtor.com, e.g. `pool`, `waterfront`, `garage`, `new construction`.

## `hasPhotos` (type: `boolean`):

Exclude listings that have no photos.

## `comingSoonOnly` (type: `boolean`):

Apply the source's coming-soon filter to for-sale modes. `COMING_SOON` mode enables it automatically.

## `sortBy` (type: `string`):

Result ordering.

## `listedSince` (type: `string`):

Only listings added on or after this date (YYYY-MM-DD). Useful for delta monitoring.

## `soldSince` (type: `string`):

In SOLD mode, only sales on or after this date (YYYY-MM-DD).

## `openHouseFrom` (type: `string`):

Only listings with an open house on or after this date (YYYY-MM-DD).

## `openHouseTo` (type: `string`):

Only listings with an open house on or before this date (YYYY-MM-DD).

## `latitude` (type: `number`):

Latitude for a radius search. Combine with longitude and radius miles.

## `longitude` (type: `number`):

Longitude for a radius search. Combine with latitude and radius miles.

## `radiusMiles` (type: `integer`):

Search radius in miles around the latitude/longitude point.

## `boundary` (type: `object`):

Search inside a GeoJSON Polygon instead of a named location. Coordinates are \[longitude, latitude]; rings may be open and are closed automatically. Example: {"type":"Polygon","coordinates":\[\[\[-95.6,29.6],\[-95.0,29.6],\[-95.0,30.1],\[-95.6,30.1],\[-95.6,29.6]]]}.

## Actor input object example

```json
{
  "mode": "BUY",
  "recordType": "PROPERTIES",
  "search": "Houston, TX",
  "startUrls": [],
  "maxItems": 3,
  "endPage": 1,
  "scrapeDetails": false,
  "propertyTypes": [],
  "keywords": [],
  "hasPhotos": false,
  "comingSoonOnly": false,
  "sortBy": "relevant"
}
```

# Actor output Schema

## `properties` (type: `string`):

Dataset containing scraped property listings and/or agent records

# 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 = {
    "mode": "BUY",
    "recordType": "PROPERTIES",
    "search": "Houston, TX",
    "startUrls": [],
    "maxItems": 3,
    "endPage": 1,
    "scrapeDetails": false,
    "propertyTypes": [],
    "keywords": [],
    "hasPhotos": false,
    "comingSoonOnly": false,
    "sortBy": "relevant"
};

// Run the Actor and wait for it to finish
const run = await client.actor("nimbryxo-studio/realtor-com-listing-and-property-detail-extractor").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 = {
    "mode": "BUY",
    "recordType": "PROPERTIES",
    "search": "Houston, TX",
    "startUrls": [],
    "maxItems": 3,
    "endPage": 1,
    "scrapeDetails": False,
    "propertyTypes": [],
    "keywords": [],
    "hasPhotos": False,
    "comingSoonOnly": False,
    "sortBy": "relevant",
}

# Run the Actor and wait for it to finish
run = client.actor("nimbryxo-studio/realtor-com-listing-and-property-detail-extractor").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 '{
  "mode": "BUY",
  "recordType": "PROPERTIES",
  "search": "Houston, TX",
  "startUrls": [],
  "maxItems": 3,
  "endPage": 1,
  "scrapeDetails": false,
  "propertyTypes": [],
  "keywords": [],
  "hasPhotos": false,
  "comingSoonOnly": false,
  "sortBy": "relevant"
}' |
apify call nimbryxo-studio/realtor-com-listing-and-property-detail-extractor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nimbryxo-studio/realtor-com-listing-and-property-detail-extractor"
        }
    }
}
```

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/76arWXzbeyTRhZQcR/builds/xJ0EyZLaPnLnZtUeM/openapi.json