# Housing Market Data API - US Home Prices, Rents and Trends (`nabeelbaghoor/housing-market-data-api`) Actor

Track US housing markets by county, city, ZIP and metro: daily price feed, sale and rent prices, event counts, for-sale inventory, gross yield, all cash share, investor and institutional ownership, and new construction. Plus unit level property records with full sale and rental event history.

- **URL**: https://apify.com/nabeelbaghoor/housing-market-data-api.md
- **Developed by:** [Nabeel Hassan](https://apify.com/nabeelbaghoor) (community)
- **Categories:** Real estate, Business, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 market returneds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Housing Market Data API - US Home Prices, Rents and Trends

Track any US county, city, ZIP code or metro area with a daily price feed, monthly sale and rent trends, inventory, yields and investor ownership, then drop to the individual property and its full sale and rental history.

### What this actor does

- **Find the market first.** Search a directory of counties, cities, ZIP codes, towns, census places and metro areas. Each row returns the market id everything else is keyed by, plus population, median income, and whether the market has a daily price feed or belongs to the Case-Shiller 10 or 20 city index.
- **24 metric series.** Daily price feed and rental price feed, housing stock, all cash share, housing event counts and prices, for-sale inventory and its price changes, new listing rolling counts, gross rental yield, rental unit concentration, investor share of the housing stock, investor purchase to sale ratio, institutional portfolio activity by portfolio size, and new construction events. One row per market per date.
- **Unit level property records.** Search properties by market, by property id, or by a radius around a point, then filter on beds, baths, size, year built, pool, new construction, owner occupancy and investor ownership. Every row carries the property's housing event history with each event's type, date and price.
- **Follow the institutions.** Filter properties by named institutional owner - Invitation Homes, Progress Residential, Amherst, Tricon, AMH, FirstKey, VineBrook, Blackstone, Opendoor and more - to map a single family rental portfolio street by street.
- **Resolve addresses.** Turn street addresses into the provider's property ids and, usefully, the ZIP, city, county and metro market ids that property sits inside, so you can go straight from an address to its market's trend data.
- **Pay per result.** You are charged for rows that carry a real record. Markets with no coverage for a metric, and addresses the provider cannot place, are free.

### Bring your own key

This actor calls the provider with **your own API key**. Paste it into the API key field, or set it as the `DATA_API_KEY` secret. Paste the key on its own without a `Bearer` prefix - this provider wants the raw key in the header, and the actor strips the prefix if you include one anyway. Nothing runs on anyone else's credentials, and a run without a key ends cleanly with an explanation rather than failing.

### Example output

```json
{
  "recordType": "metric",
  "requested": "market_metrics/housing_event_prices for market 5826765",
  "found": true,
  "metric": "market_metrics/housing_event_prices",
  "parclId": 5826765,
  "date": "2026-07-01",
  "propertyType": "SINGLE_FAMILY",
  "price_median_sales": 452000,
  "price_median_new_listings_for_sale": 469900,
  "price_median_new_rental_listings": 2295
}
```

### FAQ

#### How do I start if I only know a place name?

Run markets mode with the place name, or with a state and a geography type. Every row comes back with the provider's own market id, which is what the metric and property modes take as input. There is no way to ask for metrics by place name directly, so this step is not optional - it is the index for the whole API.

#### What is a market id?

A single number identifying one geography: a county, a city, a ZIP code, a town, a census designated place or a metro area. The same physical address sits inside four of them at once, and resolve addresses mode returns all four ids for a property so you can compare a ZIP-level trend against its county and metro.

#### Which metrics have a property type filter?

Not all of them, and sending the filter to a metric that does not take it is a rejected request rather than a harmless extra. The actor knows which is which and only sends the filter where the provider accepts it: the price feed, housing stock and investor ownership series do not take one, while sale and rental event, inventory and yield series do. The portfolio metrics take a portfolio size band instead.

#### Can I track institutional single family rental owners?

Yes, two ways. The portfolio metrics give you market-level activity split by how many homes the owner holds, from small landlords with 2 to 9 up to institutions with 1000 or more. Properties mode goes the other way: filter by a named institutional owner and get back the individual homes, with the events showing when each was bought.

#### What does the daily price feed measure?

A daily price point for residential real estate in one market, which is what makes it useful for tracking a market between monthly releases. Coverage is limited to the markets flagged as price feed markets in the directory, so check that flag before requesting it in bulk - a market without one is recorded as having no data rather than failing the run.

#### How far back does the data go?

The metric series accept a from and to date, and property event history runs back over a decade for most markets. Leave the dates empty to take everything the provider holds and use the maximum rows setting to bound the run instead.

#### What does it cost?

Pricing is pay per result: 0.005 USD per market, 0.006 USD per metric period and 0.012 USD per property record or resolved address, with Apify platform usage included. Rows the provider found nothing for are not charged. You also need your own account with the data provider, which bills credits on its own plans.

#### Does the actor fail if my key is wrong?

No. A missing key, a rejected key, an exhausted credit balance or an empty input all end the run cleanly with a message saying what to change. Only a real outage or a bug fails the run.

### Keyword map

housing market data API, US home price data, real estate market trends API, home price index API, median sale price by zip code, median rent by market, rental yield data, gross yield API, for sale inventory data, days on market trends, housing stock data, investor home purchases, institutional single family rental, Invitation Homes portfolio, Progress Residential data, new construction housing data, all cash sales share, property event history API, address to property id, real estate analytics API, housing market research data

# Actor input Schema

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

Markets searches the directory of counties, cities, ZIP codes and metros and returns the market id everything else is keyed by. Metrics reads one or more series for the markets you name. Properties searches unit level records with their event history. Resolve addresses turns street addresses into property ids and market ids.

## `marketName` (type: `string`):

Markets mode. Part of a place name to search for, for example Austin or Miami-Dade.

## `locationType` (type: `string`):

Markets mode. Which kind of geography to return. A metro area (CBSA) is the widest, a five digit ZIP the narrowest.

## `region` (type: `string`):

Markets mode. Keeps only markets in this US census region.

## `stateAbbreviation` (type: `string`):

Markets mode. The two letter state code, for example TX. Use ALL for every state.

## `geoid` (type: `string`):

Markets mode. The census geographic identifier, when you already know it.

## `singleParclId` (type: `integer`):

Markets mode. Looks up one market by the provider's own id, which is how to confirm what an id refers to.

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

Markets mode. Sorting by population is the usual way to get the largest markets first.

## `sortOrder` (type: `string`):

Markets mode. Descending puts the largest or highest first.

## `parclIds` (type: `array`):

Metrics and properties modes. One numeric market id per line. Run the actor in markets mode first to find them.

## `metrics` (type: `array`):

Metrics mode. Which series to read for each market. Every series you pick is fetched for every market, so five metrics over ten markets is fifty requests.

## `startDate` (type: `string`):

Metrics mode. The earliest period to return, written as YYYY-MM-DD.

## `endDate` (type: `string`):

Metrics mode. The latest period to return, written as YYYY-MM-DD.

## `propertyType` (type: `string`):

Metrics mode. Applied only to the metrics that accept it. The price feed, housing stock and investor ownership series do not, and it is left off those rather than sent and rejected.

## `portfolioSize` (type: `string`):

Metrics mode. Applied only to the portfolio metrics, which split institutional activity by how many single family homes the owner holds.

## `parclPropertyIds` (type: `array`):

Properties mode. One numeric property id per line, when you already know which properties you want.

## `latitude` (type: `string`):

Properties mode. The centre of a radius search. Give a longitude and a radius with it.

## `longitude` (type: `string`):

Properties mode. The centre of a radius search. Give a latitude and a radius with it.

## `radius` (type: `string`):

Properties mode. How far from the centre point to search, in miles.

## `searchPropertyTypes` (type: `array`):

Properties mode. Keeps only properties of these types.

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

Properties mode. The fewest bedrooms a property may have.

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

Properties mode. The most bedrooms a property may have.

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

Properties mode. The fewest bathrooms a property may have.

## `maxBaths` (type: `integer`):

Properties mode. The most bathrooms a property may have.

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

Properties mode. The smallest floor area in square feet.

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

Properties mode. The largest floor area in square feet.

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

Properties mode. The earliest year of construction.

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

Properties mode. The latest year of construction.

## `current_investor_owned_flag` (type: `boolean`):

Properties mode. Keeps only properties currently owned by an investor.

## `current_owner_occupied_flag` (type: `boolean`):

Properties mode. Keeps only properties the owner lives in.

## `current_on_market_flag` (type: `boolean`):

Properties mode. Keeps only properties currently listed for sale.

## `current_on_market_rental_flag` (type: `boolean`):

Properties mode. Keeps only properties currently listed for rent.

## `current_new_construction_flag` (type: `boolean`):

Properties mode. Keeps only properties currently classed as new construction.

## `has_pool` (type: `boolean`):

Properties mode. Keeps only properties with a swimming pool.

## `entityOwnerName` (type: `string`):

Properties mode. Keeps only properties held by this named institutional owner, which is how to map a single family rental portfolio.

## `includeEvents` (type: `boolean`):

Properties mode. Returns each property's housing events alongside its attributes. Turn this off for a plain property list.

## `includeFullEventHistory` (type: `boolean`):

Properties mode. Returns every recorded event rather than only the most recent ones. This makes responses considerably larger.

## `eventNames` (type: `array`):

Properties mode. Keeps only these kinds of housing event. Use ALL\_SOLD, ALL\_LISTINGS or ALL\_RENTALS to take a whole category.

## `minEventDate` (type: `string`):

Properties mode. Keeps only events on or after this date, written as YYYY-MM-DD.

## `maxEventDate` (type: `string`):

Properties mode. Keeps only events on or before this date, written as YYYY-MM-DD.

## `minEventPrice` (type: `integer`):

Properties mode. The lowest event price in dollars.

## `maxEventPrice` (type: `integer`):

Properties mode. The highest event price in dollars.

## `extraFilters` (type: `object`):

Properties mode, optional. Any further filters in the provider's own format, merged over the fields above. This is how to reach the owner filters, which narrow by owner name, seller name and whether the owner was an investor at the time of the event.

## `addresses` (type: `array`):

Resolve addresses mode. One address per line, with a street, city, state and five digit ZIP separated by commas.

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

The most rows this run will save and charge for. This is the spending control on both sides.

## `pageSize` (type: `integer`):

How many rows to ask for at a time, up to the provider's ceiling of 1000.

## `requestsPerMinute` (type: `integer`):

How fast to call the provider. Lower this if your plan rate limits the run.

## `apiKey` (type: `string`):

Your own API key for the housing market data provider, taken from your account. This actor is bring your own key: it never uses anyone else's credentials, and the key is stored as a secret. Paste the key on its own, without a Bearer prefix.

## Actor input object example

```json
{
  "mode": "markets",
  "sortOrder": "DESC",
  "current_investor_owned_flag": false,
  "current_owner_occupied_flag": false,
  "current_on_market_flag": false,
  "current_on_market_rental_flag": false,
  "current_new_construction_flag": false,
  "has_pool": false,
  "includeEvents": true,
  "includeFullEventHistory": false,
  "maxResults": 1000,
  "pageSize": 1000,
  "requestsPerMinute": 120
}
```

# Actor output Schema

## `records` (type: `string`):

One row per record, alongside the market, metric or address that produced it.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("nabeelbaghoor/housing-market-data-api").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("nabeelbaghoor/housing-market-data-api").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 '{}' |
apify call nabeelbaghoor/housing-market-data-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nabeelbaghoor/housing-market-data-api"
        }
    }
}

```

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/ERRDIZOnfBRdhEsEa/builds/SV1mObeRjWNyxHpuI/openapi.json