# Realtor.com Scraper: Every Listing, Sold Prices & Agents (`alexmorain/realtor-scraper`) Actor

Scrape every Realtor.com listing of a city, ZIP or county (for sale, for rent, sold), past the 10,000-result wall and the repeating pages, with agent email and phone. Home details, tax history, schools, new-listing and price-change monitoring.

- **URL**: https://apify.com/alexmorain/realtor-scraper.md
- **Developed by:** [Alexis Morain](https://apify.com/alexmorain) (community)
- **Categories:** Real estate, Lead generation
- **Features:** Limited permissions
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 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.
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 Scraper: every listing of a city, ZIP code or county, sold prices and agents

Realtor.com Scraper exports the listings that [Realtor.com](https://www.realtor.com) shows for a city, a ZIP code, a county or a neighborhood: homes for sale, homes for rent and sold homes. Each row has the price, the sold price and date, the address and coordinates, beds, baths, living area, lot size, year built, the description, photos, the MLS number and the listing agent with name, email, phone and brokerage.

A Realtor.com search stops serving results at 10,000, and its default order changes from page to page, so a plain read of a big city returns well under half of it. This actor cuts each search into price and date ranges small enough to be read in full, sorted by date, removes the listings found twice and returns one row per home. Every run writes a proof in its SUMMARY record: the count Realtor.com announced next to the count you received.

It works as a **Realtor.com API alternative**: no login, no browser, plain HTTP. Results land in a dataset you can export as JSON, CSV, Excel or XML, or read through the Apify API from Python, JavaScript or cURL.

#### How to scrape more than 10,000 Realtor.com listings

The table compares what Realtor.com announced with what this actor read and returned, full coverage on, runs of 18 November 2026 on the Apify platform.

| Search | Realtor.com announces | Plain read | This actor reads | Unique homes returned | Run time | Run |
|---|---|---|---|---|---|---|
| Houston, TX, for sale | 17,155 | 7,501 | 17,155 | 17,110 | 3 min 28 s | `oXoYFmnrvA2ARz1uW` |
| Austin, TX, for sale | 6,366 | 4,604 | 6,366 | 6,121 | 2 min 43 s | `vjIU8tWQUHpmrqb7z` |
| Los Angeles, CA, sold in the last 6 months | 11,284 | n/a | 11,284 | 11,207 | 2 min 41 s | `WbfzukJgu03mbCR4I` |
| Houston, TX, for rent | 14,076 | n/a | 15,465 | 13,872 | 5 min 26 s | `n03pz94tea7zti6pu` |

The plain read is 50 pages of 200 in Realtor.com's default order, the most it serves for one search (measured on 17 November). In that order the same homes come back on several pages, and the read stops at 10,000 anyway.

Why fewer unique homes than announced: Realtor.com counts listings, and the same home can be listed by two MLSs, each with its own listing id. Austin had 245 such homes. The actor returns one row per home (`propertyId`) and charges it once. For rentals, a listing with a rent range shows up in several price ranges, so the actor reads more rows than announced and keeps one per home.

The SUMMARY record of the Houston for sale run:

```json
{
  "monitorMode": "off",
  "listingsReturned": 17110,
  "byEvent": {"listing": 17110},
  "searches": [{
    "search": "Houston, TX",
    "listingType": "forSale",
    "announced": 17155,
    "listingsRead": 17155,
    "retrieved": 17110,
    "subSearches": 9,
    "walledSubSearches": 0,
    "failedPages": 0,
    "complete": true
  }],
  "requests": 113,
  "retried": 4
}
```

When `listingsRead` equals `announced`, nothing was left out. `subSearches` is the number of ranges the search was cut into. `walledSubSearches` counts the ranges that still held more than 10,000 listings after every possible cut (one price, one day); it is 0 in every test run so far, and the status message names it when it is not.

### Why use a Realtor.com scraper

- **Investors and analysts**: every home of a metro area with price, size, year built, sold price and coordinates, for a spreadsheet, a notebook or a price model.
- **Agents, lenders, title and home service companies**: lists of listing agents with email, phone and brokerage, by ZIP code or county, and a daily feed of new listings.
- **PropTech and data teams**: complete, deduplicated rows with a stable property id, plus tax history, value estimates, schools and flood factor when you need them.
- **Rental watchers**: rentals by ZIP code with monthly rent, pet policy and new listings each day.

What you get on top of a plain search export:

- Full coverage past the 10,000 wall and past the repeating pages, with the announced count against the returned count in every run.
- Sold prices and dates, in the states that publish them.
- The listing agent on the search row: name, email, phone numbers and brokerage, no second request.
- Optional home page data per listing: price and sale history, tax history, value estimates, nearby schools, flood factor, open houses, pet policy, HOA fee.
- A watch mode that returns only new listings, or new listings plus price changes with the previous price, and a webhook at the end of the run.
- Proxies included in the price, and Apify scheduling, API access and integrations (Make, Zapier, n8n, Google Sheets).

### How to scrape Realtor.com listings, step by step

1. Open the actor in Apify Console and go to the Input tab.
2. In **Places**, type what you would type in Realtor.com's search box: `Austin, TX`, `78701`, `Travis County, TX` or `Hyde Park, Austin, TX`. Each place is read separately.
3. Pick **For sale**, **For rent** or **Sold**, and add filters if you want a subset.
4. Set **Max listings**. Use 100 for a first test. 0 means the whole area, tens of thousands of listings for a large city.
5. Turn on **Include home page details** if you need the history, tax, estimate and school fields. Leave **Full coverage** on to get more than 10,000 rows.
6. Click **Start**. The status message ends with the announced count against the returned count.
7. Download the dataset from the Output tab as JSON, CSV or Excel, or read it through the API.

### Scrape Realtor.com by city, ZIP code, county or search URL

#### Places (`locations`)

City and state, ZIP code, county or neighborhood. Realtor.com resolves the place itself: `Travis County, TX` announced 9,775 listings for sale, ZIP code `78701` 244, the Hyde Park neighborhood of Austin 24 (17 November 2026). A place Realtor.com does not know ends as not found, and the status message names it. A single place that fails does not stop the others.

#### Realtor.com search URLs (`startUrls`)

A search page copied from realtor.com, such as `https://www.realtor.com/realestateandhomes-search/Austin_TX/beds-3/price-300000-600000` or `https://www.realtor.com/apartments/Denver_CO`. The actor reads the place, the listing type (for sale, rent or sold) and the filters written in the URL path: price, beds, baths, home type, living area, lot size, year built, new construction and hide pending. A path filter it does not know is named in the log and ignored. Filters you set in the input fields apply on top, for the listing type of the URL.

#### Filters

| Field | What it does |
|---|---|
| `minPrice`, `maxPrice` | Price for sale and sold, monthly rent for rentals, in USD |
| `minBeds`, `maxBeds` | Bedrooms |
| `minBaths` | Bathrooms |
| `minSqft`, `maxSqft` | Living area, square feet |
| `minLotSqft`, `maxLotSqft` | Lot size, square feet |
| `minYearBuilt`, `maxYearBuilt` | Year built |
| `homeTypes` | house, condo, townhouse, multiFamily, lot, manufactured, farm |
| `daysOnRealtor` | 1, 7, 14, 30, 90, 6m, 12m, 24m or 36m. For sold homes it is the sale window |
| `newConstructionOnly` | New construction only |
| `hidePending` | Leave out homes under contract |

#### Full coverage and home page details

**Full coverage** is on by default. A search that announces more than 4,000 listings is cut in two by price, then each half again, until every range holds 4,000 or fewer. Ranges are read sorted by date, newest first, so a range read in full gives each listing once. Sold searches are cut by sale date first, then by price. With a small **Max listings** and no watch, the actor reads the newest listings without cutting.

**Include home page details** (`includeDetails`) reads the Realtor.com home page of each listing and adds its fields to the row. The row is charged as a detailed listing instead of a plain one, not on top of it. If a home page cannot be read, the row keeps the search fields, `hasDetails` is false, and it is charged as a plain listing.

### What data does the Realtor.com scraper extract?

Fields that Realtor.com does not show for a given home come back as null, so every row has the same keys.

| Field | Type | Description |
|---|---|---|
| `propertyId` | string | Realtor.com property id (the M number of the listing URL). Use it to deduplicate |
| `listingId` | string | Id of the current listing of this property |
| `url` | string | Listing page on Realtor.com |
| `status` | string | forSale, forRent, sold or readyToBuild |
| `listPrice` | number | Asking price in USD, monthly rent for rentals |
| `priceReducedAmount` | number | Amount of the last price cut |
| `soldPrice` | number | Sale price for sold homes. Empty in non-disclosure states such as Texas |
| `soldDate` | string | Sale date for sold homes, YYYY-MM-DD |
| `lastSoldDate` | string | Date of the last recorded sale of the property |
| `lastSoldPrice` | number | Price of the last recorded sale. Empty in non-disclosure states |
| `listDate` | string | Date and time the listing appeared on Realtor.com, UTC |
| `lastUpdateDate` | string | Last update of the listing, UTC |
| `address`, `street`, `city`, `state`, `postalCode` | string | Address |
| `county`, `countyFips` | string | County and its FIPS code |
| `latitude`, `longitude` | number | Coordinates |
| `propertyType`, `propertySubType` | string | single_family, condos, townhomes, multi_family, land, mobile, farm, apartment... |
| `beds`, `baths`, `bathsFull`, `bathsHalf` | number | Bedrooms and bathrooms |
| `sqft`, `lotSqft` | number | Living area and lot size, square feet |
| `yearBuilt`, `garage`, `stories` | number | Year built, garage spaces, stories |
| `description` | string | Listing description written by the agent |
| `isNewListing`, `isNewConstruction`, `isPriceReduced`, `isPending`, `isComingSoon` | boolean | Realtor.com flags |
| `primaryPhoto`, `photos` | string, array | Main photo and all photo URLs |
| `tags` | array | Feature tags (central_air, garage_2_or_more, fenced_yard...) |
| `mlsId`, `mlsListingId` | string | MLS code and the listing number in that MLS |
| `agentName`, `agentEmail`, `agentPhones`, `agentOffice` | string, array | Listing agent and brokerage, as the listing shows them |
| `searchLocation` | string | The place of the search that returned this row |
| `hasDetails` | boolean | True when the home page was read (charged as a detailed listing) |
| `previousPrice`, `priceChange` | number, string | Watch mode: price at the previous run, and new, up or down |
| `scrapedAt` | string | When the run read the search, UTC |
| `propertyHistory` | array | Details: listing, price change and sale events (date, event, price, source) |
| `taxHistory` | array | Details: property tax and assessed values per year |
| `estimates`, `bestEstimate` | array, number | Details: automated value estimates by source, and the one Realtor.com shows first |
| `schools` | array | Details: nearby schools with distance, rating, levels, grades and funding |
| `floodFactorScore`, `floodFactorSeverity` | number, string | Details: First Street flood factor, 1 to 10, and in words |
| `openHouses` | array | Details: upcoming open houses |
| `petPolicy` | object | Details: cats and dogs allowed (rentals) |
| `hoaFee` | number | Details: monthly HOA fee |

How full the agent fields are, measured on 18 November 2026: on Houston for sale, the agent name is on 98 % of the rows, the email on 82 % and a phone on 94 %. On Los Angeles sold homes, 80 % have an email. New construction listings are often published by a builder community without an agent, which is why a city with many new homes (Austin) has fewer emails. On a sample of home pages, tax history and value estimates were on 77 to 78 % of the rows, schools on all of them and the flood factor on 98 %.

#### Example row

A real row from Austin, for sale, 18 November 2026, with the photo and tag lists shortened:

```json
{
  "propertyId": "7764405867",
  "listingId": "3003712067",
  "url": "https://www.realtor.com/realestateandhomes-detail/9012-Tall-Sky-Trce_Austin_TX_78724_M77644-05867",
  "status": "forSale",
  "listPrice": 275000,
  "lastSoldDate": "2023-04-14",
  "listDate": "2026-11-17T23:43:56Z",
  "address": "9012 Tall Sky Trce, Austin, TX 78724",
  "city": "Austin",
  "state": "TX",
  "postalCode": "78724",
  "county": "Travis",
  "latitude": 30.273832,
  "longitude": -97.633552,
  "propertyType": "single_family",
  "beds": 4,
  "baths": 3,
  "sqft": 2125,
  "lotSqft": 11273,
  "yearBuilt": 2009,
  "garage": 4,
  "stories": 2,
  "isNewListing": true,
  "photos": ["https://ap.rdcpix.com/34d7ede0760b5c22f2fdc6982729a5b4l-m2441438747s.jpg"],
  "tags": ["central_air", "garage_2_or_more"],
  "mlsId": "ZIPR",
  "searchLocation": "Austin, TX",
  "hasDetails": true,
  "propertyHistory": [
    {"date": "2026-11-17", "event": "Listed", "price": 275000, "source": "Zillow"},
    {"date": "2023-03-09", "event": "Price Changed", "price": 455000, "source": "UnlockMLS"}
  ]
}
```

### Realtor.com new listing and price drop tracker

Set **Monitor mode** to get a feed instead of a full export.

- **New listings only** (`newOnly`) returns the listings that no earlier run with the same input returned.
- **New listings and price changes** (`newAndPriceChanges`) also returns listings whose price moved, with `previousPrice` and `priceChange` (up or down). Listings new to the watch get `priceChange` new.

The first run returns everything. After that, unchanged listings are not pushed and not charged. A watch reads the whole search and compares it with its memory, so nothing is missed when Realtor.com reorders its results.

The memory lives in a named key-value store in your account called `realtor-scraper-monitor`, one record per search and per watch. Runs that share the same input and the same **Monitor name** share one memory; change the name to start a second, separate watch on the same search. A listing joins the memory only after it was delivered, so one cut by Max listings or by the maximum charge comes back in the next run. Entries older than 180 days are forgotten.

To schedule it, open Schedules in Apify Console, pick the actor, paste the input and set a cron expression. A daily run at 7:00 with a watch on gives you what changed since yesterday.

**Webhook.** Set **Webhook URL** to get a POST at the end of every run. The JSON body carries `actor`, `runId`, `datasetId`, `monitorMode`, `status`, `searches`, `failedSearches`, `listings`, `listingsWithDetails`, `priceChanges`, `skippedAlreadySeen` and `chargeLimitReached`, plus the status message in `text` (Slack) and `content` (Discord). A webhook that fails is logged and does not fail the run.

### How much does it cost to scrape Realtor.com?

The actor uses Apify's pay-per-event pricing. You pay for events; proxies are included.

| Event | Charged when | Free | Bronze | Silver | Gold, Platinum, Diamond |
|---|---|---|---|---|---|
| Listing | A unique listing is returned from a search | $1.00 per 1,000 | $0.87 | $0.73 | $0.50 |
| Detailed listing | A listing is returned with its home page data. Charged instead of Listing | $2.00 per 1,000 | $1.70 | $1.50 | $1.00 |
| Actor start | The run starts, per GB of memory (512 MB by default) | $0.002 | $0.002 | $0.002 | $0.002 |

The plan tier is the one of your Apify subscription. A listing found twice in a run is charged once. A listing skipped by the watch because it was already returned is not charged. A home page that could not be read is charged as a plain listing.

Example: a search that returns 10,000 listings, 1,000 of them with their home page (9,000 Listing events and 1,000 Detailed listing events). That costs $11.00 on Free (9,000 x $0.00100 + 1,000 x $0.00200), $9.53 on Bronze, $8.07 on Silver and $5.50 on Gold, start event not included.

Other examples at the Free rate: Houston, all 17,110 for sale homes, about $17.11; a daily watch on a ZIP code that sees 15 new listings a day, about $0.017 a run. To keep a test cheap, set **Max listings** or the maximum charge per run in the run options: at the maximum charge the actor stops and keeps the rows it already read.

### Scrape Realtor.com with Python, JavaScript or cURL

These examples use the actor `alexmorain/realtor-scraper`. Replace the token with your own and keep it in an environment variable.

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("alexmorain/realtor-scraper").call(run_input={
    "locations": ["Austin, TX", "78701"],
    "listingType": "forSale",
    "minPrice": 300000,
    "maxPrice": 900000,
    "minBeds": 3,
    "homeTypes": ["house", "townhouse"],
    "daysOnRealtor": "30",
    "maxItems": 2000,
})

for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["address"], row["listPrice"], row["agentEmail"])

summary = client.key_value_store(run["defaultKeyValueStoreId"]).get_record("SUMMARY")["value"]
for entry in summary["searches"]:
    print(entry["search"], entry["announced"], entry["retrieved"])
```

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('alexmorain/realtor-scraper').call({
    locations: ['Los Angeles, CA'],
    listingType: 'sold',
    daysOnRealtor: '90',
    maxItems: 0,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length, 'sold homes, median price',
    items.map((r) => r.soldPrice).filter(Boolean).sort((a, b) => a - b)[Math.floor(items.length / 2)]);
```

#### cURL

Start a run and wait for the rows in one call:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/alexmorain~realtor-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"locations": ["78701"], "listingType": "forRent", "maxItems": 200}'
```

A synchronous call times out after five minutes: use it for short runs. For a whole city, start the run with `POST /v2/acts/alexmorain~realtor-scraper/runs` and read the dataset when it ends.

### Limits of this Realtor.com scraper, written plainly

- **United States only.** A place outside the US ends as not found.
- **No sold prices in non-disclosure states.** Texas, Utah and a dozen other states do not publish sale prices, so `soldPrice` and `lastSoldPrice` stay empty there. The sale date is still there.
- **Unique homes are fewer than the announced count.** Realtor.com counts a home listed by two MLSs twice; the actor returns it once. Compare `listingsRead` with `announced` to check that nothing was left out.
- **Rentals cannot be checked to the unit.** A rental with a rent range appears in several price ranges, so `listingsRead` is above `announced` and does not prove completeness on its own. Houston returned 13,872 unique rentals for 14,076 announced.
- **Agent contacts are the listing's.** Email and phone are what the listing shows. New construction published by a builder community has no agent, and the fields are empty.
- **Not extracted**: agent directory pages and agent reviews. They are not part of the listing data this actor reads.
- **Realtor.com can refuse requests.** The actor changes IP and retries, and moves to US residential IPs if datacenter IPs are refused from the start. If Realtor.com refuses everywhere, the run ends FAILED with a message instead of returning a half empty dataset.

### Realtor.com scraper FAQ

#### How to scrape more than 10,000 listings from Realtor.com?

A Realtor.com search serves 10,000 results at most, and its default order repeats listings from page to page. To get a whole area, the search has to be cut into smaller ranges, each read in full in a stable order, and the results merged without duplicates. That is what full coverage does. Houston announced 17,155 listings for sale; the actor read all 17,155 and returned 17,110 unique homes (run `oXoYFmnrvA2ARz1uW`).

#### Can I scrape Realtor.com by ZIP code?

Yes. Type the ZIP code in **Places**, for example `78701`. You can pass many ZIP codes in the same run, and each one gets its own line in the SUMMARY record.

#### Can I get sold prices from Realtor.com?

Yes, with **Listing type** set to Sold, in the states that publish sale prices. `daysOnRealtor` sets the sale window, from the last day to the last 36 months.

#### Can I get the listing agent's email and phone?

Yes, on the search row, with no extra charge: `agentName`, `agentEmail`, `agentPhones` and `agentOffice`.

#### Is it legal to scrape Realtor.com?

This is not legal advice. The data this actor reads is what Realtor.com shows to any visitor of its public pages: no login, no private account data. Whether collecting it is allowed depends on what you do with it, where you are and Realtor.com's terms of use, which limit automated access and the reuse of its content. Read them before building a product on the data. The listing data contains personal data: the name, email and phone number of listing agents. In the European Union the GDPR applies to it, and in the US state privacy laws, CAN-SPAM and the rules on unsolicited calls and texts (TCPA) may apply. Do not use agent contacts for mass cold calling or messaging, keep only what you need, and ask a lawyer if the use is commercial and at scale.

### Disclaimers and support

Our actors do not extract private user data. They only extract what Realtor.com shows publicly. Your results can still contain personal data, such as the name, email and phone number of a listing agent. Personal data is protected by the GDPR in the European Union and by other regulations around the world. Do not scrape personal data unless you have a legitimate reason, and if you are unsure whether yours is legitimate, consult a lawyer. This actor is not affiliated with or endorsed by Realtor.com or Move, Inc.

Something wrong or missing? Use the Issues tab of this actor. Send the run id and the input. The API tab has the endpoints and ready-made code to start the actor from your own tools.

### Guide and use cases

Use cases for outbound and automation, the output fields, pricing and common questions are on the [Realtor.com Scraper page](https://alexis.morain.fr/en/scrapers/realtor-scraper/) of my site. The [Classifieds and real estate family page](https://alexis.morain.fr/en/scrapers/families/classifieds-real-estate/) puts it side by side with the other scrapers of the same family.

# Actor input Schema

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

City, ZIP code, county or neighborhood, written as on Realtor.com: <code>Austin, TX</code>, <code>78701</code>, <code>Travis County, TX</code>, <code>Hyde Park, Austin, TX</code>. One search per place.

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

Or paste search pages from your browser, e.g. <code>https://www.realtor.com/realestateandhomes-search/Austin_TX/beds-3/price-300000-500000</code>, <code>/apartments/Houston_TX</code>, <code>/show-recently-sold</code>. The place, listing type and filters in the URL are kept; filters below fill the ones the URL does not set.

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

Applies to the places above. A pasted URL keeps its own type.

## `minPrice` (type: `integer`):

Monthly rent for rentals.

## `maxPrice` (type: `integer`):

Monthly rent for rentals.

## `minBeds` (type: `integer`):

0 = studios included.

## `maxBeds` (type: `integer`):

Use 0 for studios only.

## `minBaths` (type: `integer`):

Full and half bathrooms counted as Realtor.com counts them.

## `minSqft` (type: `integer`):

Interior living area.

## `maxSqft` (type: `integer`):

Interior living area.

## `minLotSqft` (type: `integer`):

1 acre = 43,560 sq ft.

## `maxLotSqft` (type: `integer`):

1 acre = 43,560 sq ft.

## `minYearBuilt` (type: `integer`):

Year built, e.g. 2000.

## `maxYearBuilt` (type: `integer`):

Year built, e.g. 2020.

## `homeTypes` (type: `array`):

Leave empty for all types.

## `daysOnRealtor` (type: `string`):

Only listings that appeared on Realtor.com (or, for sold homes, sold) within this window. Leave empty for no limit.

## `newConstructionOnly` (type: `boolean`):

Only newly built homes.

## `hidePending` (type: `boolean`):

For sale only. Realtor.com includes homes under contract in its for-sale results by default (907 of 6,392 in Austin on 17/11/2026).

## `fullCoverage` (type: `boolean`):

Get every listing of the area. One Realtor.com search stops at 10,000 results and its default order repeats listings from page to page; the actor splits big areas by price (sold homes by sale date) and reads each part sorted by date. The SEARCHES record shows the count Realtor announced next to the count returned.

## `includeDetails` (type: `boolean`):

Also read each home page: price and sale history, tax history and assessed values, value estimates, nearby schools, flood score, open houses, pet policy, HOA fee. Charged as a detailed listing instead of a listing.

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

Stop after this many listings in the whole run. 0 = no limit. With a small limit, the newest listings come first.

## `monitorMode` (type: `string`):

For scheduled runs: return only listings not returned by an earlier run with the same searches (and, if chosen, listings whose price changed, with <code>previousPrice</code> and <code>priceChange</code>). Listings skipped this way are not charged.

## `monitorName` (type: `string`):

Keeps the monitor memory under this name, so you can change searches or filters without starting over. Different names = separate memories.

## `webhookUrl` (type: `string`):

Receives a JSON summary (status, listings, price changes, run id, dataset id) when the run ends. Slack, Discord, Zapier and Make URLs work. Never logged.

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

Apify datacenter proxy by default, which Realtor.com's data endpoint accepts; the actor switches to US residential IPs by itself if datacenter IPs are refused. Leave as is.

## Actor input object example

```json
{
  "locations": [
    "Austin, TX"
  ],
  "listingType": "forSale",
  "newConstructionOnly": false,
  "hidePending": false,
  "fullCoverage": true,
  "includeDetails": false,
  "maxItems": 1000,
  "monitorMode": "off",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `listings` (type: `string`):

One row per listing, main fields

## `dataset` (type: `string`):

Every listing with all fields

## `searches` (type: `string`):

Per search: listings announced by Realtor.com, unique listings retrieved, sub-searches, wall hits, failed pages

# 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 = {
    "locations": [
        "Austin, TX"
    ],
    "maxItems": 1000,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("alexmorain/realtor-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 = {
    "locations": ["Austin, TX"],
    "maxItems": 1000,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("alexmorain/realtor-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 '{
  "locations": [
    "Austin, TX"
  ],
  "maxItems": 1000,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call alexmorain/realtor-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,alexmorain/realtor-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/DlBXPkr16AXSIvZCd/builds/dPgqmiUffblbiAbzp/openapi.json
