# Realtor Property Scraper (Cheap) (`data_api/realtor-property-scraper-cheap`) Actor

Realtor.com property details scraper that extracts price, beds, baths, sqft, tax history, and school ratings from any US address or property ID, so investors and agents can pull structured listing data at scale.

- **URL**: https://apify.com/data\_api/realtor-property-scraper-cheap.md
- **Developed by:** [Data API](https://apify.com/data_api) (community)
- **Categories:** Real estate, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.99 / 1,000 results

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

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#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

## Realtor Property Details Scraper

![Realtor Property Details Scraper](cover.jpg)

Pulling property data off Realtor.com by hand is slow: you search an address, open the listing, copy the price, scroll for the beds and baths, dig for the last sale, then repeat for the next one. This scraper skips all of that. Hand it a US address or a numeric property ID and it resolves the listing, calls Realtor.com directly, and gives you back the asking price, beds, baths, square footage, year built, last-sold history, and location already split into clean fields. No account, no browser, no manual lookups. Run one address or a list of thousands.

### What you get

Each entry becomes one tidy row. Whatever the listing doesn't expose comes back as `null` rather than disappearing, so your columns stay lined up when you open the results in a sheet or load them into a database. Three kinds of data per property:

- **Price and history** — `askingPrice`, `soldPrice`, `soldDate`, `updatedDate`, `listingStatus`
- **Home details** — `bedroomCount`, `bathroomCount`, `livingAreaSqft`, `constructionYear`, `homeType`
- **Location and reference** — `streetAddress`, `cityName`, `stateCode`, `zipCode`, `listingUrl`, `listingId`, `queryInput`, plus the full `rawListing` object for anything deeper

### Quick start

1. Hit **Try for free** and open the input form.
2. Paste your US addresses or Realtor.com property IDs into **Addresses or property IDs** — one per line, and you can mix the two.
3. Pick a proxy type and set a **Results limit** if you want to cap the run.
4. Press **Start**, then export the rows as JSON, CSV, Excel, or XML once it finishes.

![How it works](how-it-works.jpg)

### Use cases

- **Investment research** — pull asking price, last-sold price, and home specs for a watchlist of addresses and flag the ones that look underpriced
- **Market analysis** — line up beds, baths, square footage, and price across a neighborhood to read pricing trends without clicking through Realtor.com
- **Lead enrichment** — bolt property specs onto a CRM export so every address carries beds, baths, square footage, year built, and listing status
- **Off-market tracking** — keep an eye on addresses that sit off-market and catch the moment one comes back as for sale
- **Portfolio valuation** — batch a list of owned homes to grab current prices, recent changes, and the raw listing record in a single run
- **Data pipelines** — feed structured home data into Google Sheets, Airtable, or a database on a schedule with Apify integrations

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `lookupValues` | array of strings | Yes | US addresses or Realtor.com property IDs to look up. Mix both in the same run; one entry per line. |
| `resultsLimit` | integer | No | Cap on how many entries to handle per run. Default `50`; set `0` for no cap. |
| `timeoutSeconds` | integer | No | Seconds to wait on each HTTP call before moving on. Default `45`; raise it on residential proxies. |
| `proxyConfiguration` | object | No | Proxies used for requests. Defaults to US datacenter; switch to Residential if datacenter IPs get blocked. |

#### Example input

```json
{
    "lookupValues": [
        "9874561230",
        "88 Birchwood Ln, Boise, ID 83702",
        "204 Sandpiper Cove Dr Unit 3"
    ],
    "resultsLimit": 50,
    "timeoutSeconds": 45,
    "proxyConfiguration": { "useApifyProxy": true, "apifyProxyCountry": "US" }
}
```

### Output

Every entry produces one row, and every field is always present — values the listing doesn't carry come back as `null`, so the dataset stays rectangular. The flat columns cover the essentials, while `rawListing` holds the complete API response for tax history, schools, photos, estimates, and more.

#### Example output

```json
{
    "queryInput": "88 Birchwood Ln, Boise, ID 83702",
    "listingId": "9874561230",
    "listingStatus": "for_sale",
    "askingPrice": 615000,
    "soldPrice": 478000,
    "soldDate": "2020-09-30",
    "updatedDate": "2026-05-21",
    "bedroomCount": 4,
    "bathroomCount": 3,
    "livingAreaSqft": 2480,
    "constructionYear": 2004,
    "homeType": "single_family",
    "streetAddress": "88 Birchwood Ln",
    "cityName": "Boise",
    "stateCode": "ID",
    "zipCode": "83702",
    "listingUrl": "https://www.realtor.com/realestateandhomes-detail/88-Birchwood-Ln_Boise_ID_83702",
    "rawListing": {
        "description": { "lot_sqft": 8700, "garage": 2, "pool": false, "heating": "Forced Air", "cooling": "Central" },
        "tax_history": [{ "year": 2023, "tax": 5900 }, { "year": 2022, "tax": 5600 }],
        "schools": { "schools": [{ "name": "Birchwood Elementary", "rating": 9, "distance_in_miles": 0.3 }] },
        "estimates": { "current_values": [{ "estimate": 622000 }] },
        "photos": [{ "href": "https://ap.rdcpix.com/..." }],
        "mortgage": { "estimate": { "monthly_payment": 3380 } },
        "property_history": [{ "date": "2020-09-30", "event_name": "Sold", "price": 478000 }],
        "local": { "flood": { "flood_factor_score": 1 }, "noise": { "score": 38 } }
    }
}
```

#### Output fields

| Field | Type | Description |
|-------|------|-------------|
| `queryInput` | string | The exact address or property ID you submitted for this row |
| `listingId` | string | Realtor.com property identifier (mpr\_id) resolved for the entry |
| `listingStatus` | string | Listing state: `for_sale`, `sold`, `off_market`, `pending`, and similar |
| `askingPrice` | number | Current list price in USD |
| `soldPrice` | number | Amount the home last changed hands for, in USD |
| `soldDate` | string | Date of the most recent sale |
| `updatedDate` | string | When the listing was last refreshed on Realtor.com |
| `bedroomCount` | number | How many bedrooms the home has |
| `bathroomCount` | number | How many bathrooms the home has |
| `livingAreaSqft` | number | Interior floor area in square feet |
| `constructionYear` | number | Year the home was originally built |
| `homeType` | string | Kind of home, for example `single_family`, `condo`, or `townhouse` |
| `streetAddress` | string | Street line of the property address |
| `cityName` | string | City the property sits in |
| `stateCode` | string | Two-letter state abbreviation |
| `zipCode` | string | ZIP or postal code |
| `listingUrl` | string | Full link to the property page on Realtor.com |
| `rawListing` | object | Complete unprocessed property object with tax history, schools, photos, estimates, mortgage info, and more |

### Tips for best results

- **Start small.** Run 10 entries before committing to hundreds — address-format and proxy issues show up in the first few rows.
- **Mix addresses and IDs freely.** Numeric entries are treated as property IDs and used directly; everything else goes through the address resolver, so a single list can hold both.
- **Switch to Residential if results come back empty.** US datacenter proxies clear most lookups; residential helps when large batches start returning null rows.
- **Cap test runs with `resultsLimit`.** Set it to 20–50 while you confirm the output fits your pipeline, then drop it to `0` for the full batch.
- **Raise `timeoutSeconds` to ~60** when running on slower residential proxies so single slow responses don't time out.
- **Reach for `rawListing`** when the flat columns aren't enough — tax records, school ratings, flood scores, and price history all live inside it.

### How can I use Realtor.com property data?

**How can I use the Realtor Property Details Scraper to research a list of addresses at once?**
Paste your addresses or property IDs into `lookupValues`, one per line, and the scraper returns each home's asking price, last-sold price, beds, baths, square footage, and status as a single row. Set `resultsLimit` to `0` and the whole batch runs in one go — a quick base layer for any Realtor.com property research.

**How can I get Realtor.com property data without an account or API key?**
You don't need either. The scraper resolves an address to a Realtor.com property ID, fetches the listing, and hands back the structured fields plus the raw record. Drop in a numeric ID to skip the lookup step, or a plain address to let the resolver do the matching.

**How can I enrich a CRM or spreadsheet with home details from Realtor.com?**
Feed the scraper the addresses you already have and append the columns it returns — `askingPrice`, `bedroomCount`, `bathroomCount`, `livingAreaSqft`, `constructionYear`, and `listingStatus` — straight onto each contact. Export to CSV or Excel, or pipe the data into Google Sheets or Airtable with an Apify integration to keep it current.

**How can I track sold and off-market homes on Realtor.com?**
Run a list of addresses on a schedule and watch `listingStatus`, `soldPrice`, and `soldDate` change over time. The scraper returns data for active, pending, off-market, and recently sold homes alike, so you can catch when a property's status flips and act on it.

### Is it legal to scrape data?

Our actors are ethical and do not extract any private user data, such as email addresses or private contact information. They only extract what the user has chosen to share publicly. We therefore believe that our actors, when used for ethical purposes by Apify users, are safe.

However, you should be aware that your results could contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

You can also read Apify's blog post on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

### Support

Questions, feature requests, or a field you'd like added? Reach out at <data.apify@proton.me> and we'll get back to you.

# Actor input Schema

## `lookupValues` (type: `array`):

The US addresses or numeric Realtor.com property IDs you want details for. Mixing the two is fine — type a full address such as '88 Birchwood Ln, Boise, ID 83702' or paste a numeric ID like '9874561230'. Add one entry per line.

## `resultsLimit` (type: `integer`):

Cap on how many entries to handle in a single run. Handy for quick test runs or keeping spend in check. Use 0 to lift the cap.

## `timeoutSeconds` (type: `integer`):

Seconds to wait on each HTTP call before giving up and moving to the next entry. Raise it if slower proxy tiers throw timeout errors.

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

Proxies used for the requests, which help you dodge IP blocks and rate limits. US datacenter proxies are the fastest and cover most lookups; residential proxies are harder for the site to spot.

## Actor input object example

```json
{
  "lookupValues": [
    "9874561230",
    "88 Birchwood Ln, Boise, ID 83702",
    "204 Sandpiper Cove Dr Unit 3"
  ],
  "resultsLimit": 50,
  "timeoutSeconds": 45,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyCountry": "US"
  }
}
```

# 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 = {
    "lookupValues": [
        "3291777140",
        "3808 Warm Meadows St, Las Vegas",
        "13018 Lumberjack Rd NW Unit 1"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("data_api/realtor-property-scraper-cheap").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 = {
    "lookupValues": [
        "3291777140",
        "3808 Warm Meadows St, Las Vegas",
        "13018 Lumberjack Rd NW Unit 1",
    ],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyCountry": "US",
    },
}

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

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

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

```

## CLI example

```bash
echo '{
  "lookupValues": [
    "3291777140",
    "3808 Warm Meadows St, Las Vegas",
    "13018 Lumberjack Rd NW Unit 1"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyCountry": "US"
  }
}' |
apify call data_api/realtor-property-scraper-cheap --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=data_api/realtor-property-scraper-cheap",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/2i28iTVcqY6wQx1kb/builds/gIk4PXLpgRfcEgrpY/openapi.json