# Home Value Estimate API - AVM, Rent, Forecast, Market (`nabeelbaghoor/home-value-estimate-api`) Actor

Get an automated home value estimate with its confidence range, a rental estimate, property characteristics, sales and tax history, flood and hazard risk, and postcode or metro price forecasts. Batches up to 100 addresses in one request. Bring your own key.

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

## Pricing

from $15.00 / 1,000 property record 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

## Home Value Estimate API - AVM, Rent, Forecast, Market

Turn a list of addresses into automated value estimates with their confidence range, rental estimates, characteristics, risk scores and the market conditions around them. Up to a hundred addresses per request.

This actor calls a residential property valuation and analytics API on your behalf and stores one row per property, geography or market reading. Bring your own key: paste your account key and secret into the input and the run uses your own plan and your own contract.

### What you get

- **A valuation with its uncertainty attached.** The value estimate, its upper and lower bounds, and the forecast standard deviation, which is the model's own statement of how far off it expects to be. The same three for the rental estimate.
- **126 analytics components, mixed freely.** Pick any combination in one run: value, rental value, characteristics, sales history, tax history, schools, flood, FEMA disaster areas, census, land value, mortgage liens, notices of default, owner occupancy, loan to value at origination and today, value forecasts, value within the block, and the postcode, block, metropolitan and state series that surround the property.
- **Seven levels.** An individual property, a census block, a census block group, a postcode, a metropolitan division, a metropolitan statistical area or a state. Components name their own level, and a component from the wrong one is refused before the first request rather than after it.
- **Real batching.** A hundred items per request, answered in the order they were sent, which is what makes a long address list affordable.
- **Market pulse.** Median days on market and its moving average, median list price and price per square foot, active and new listings, listings removed, the share with a price reduction, and months of supply, for sale or rental, as a snapshot or a time series.
- **Per component outcomes.** Every row records what each component returned rather than collapsing a partial answer into one verdict, so you can tell a property with no tax record from one the provider has never seen.
- **Nothing thrown away.** The curated columns sit at the top level for sorting and filtering; the whole result of every component rides along in `components`.

### Pay per result

You are charged per record, never per request or per component, and only for rows that carry real data. An address the provider has nothing for is stored with the reason and costs nothing.

| Event | Price | What it covers |
| --- | --- | --- |
| Property record returned | $0.015 | One property or geography with every component requested, valuation, rent and characteristics |
| Market reading returned | $0.006 | One market pulse snapshot, or one period of a time series |

### Quick start

1. Get an API key and API secret from your provider account settings.
2. Paste them into **API key** and **API secret**. Both halves are required.
3. Leave **Level** on property, put one address in **Items**, and leave **Components** on value and details.
4. Set **Maximum rows** to the most you want to pay for.
5. Run it.

### FAQ

#### What is an AVM?

An automated valuation model estimates a home's current market value from comparable sales, public records and property characteristics, without anybody visiting the property. This one returns the estimate together with an upper bound, a lower bound and a forecast standard deviation, so the row tells you how much to trust the number as well as what the number is.

#### What is the forecast standard deviation and why does it matter?

The forecast standard deviation, usually written FSD, is the model's expected error expressed as a fraction of the value. An FSD of 0.05 on a $325,000 estimate means the model expects to be within about five percent. The upper and lower bounds are derived from it. When a valuation is going into a lending, insurance or acquisition decision, the FSD is the field that decides whether the estimate is usable.

#### How do I write an address?

Three ways. An address followed by a postcode, such as `10216 N Willow Ave, 64157`. An address followed by a city and a two letter state, such as `65239 Rosanne Prairie St, Bayardchester, CA`. Or the provider's own readable slug, such as `65239-Rosanne-Prairie-Bayardchester-CA-90113`. A line that names a street but no place is refused with an explanation, because the provider cannot place a street on its own and would answer it as an ordinary miss.

#### What is a component?

A component is one endpoint for one item: `property/value` for one address, `zip/hpi_ts_forecast` for one postcode. Components are how this API is organised and also how it is metered, so asking for four components across a hundred addresses counts as four hundred against the provider's rate limit even though it travels as one request. This actor logs that arithmetic before it starts.

#### Can I get a rental estimate as well as a sale value?

Yes. Add `property/rental_value` alongside `property/value` and both come back on the same row, each with their own bounds and forecast standard deviation. `property/rental_value_forecast` and `property/rental_value_within_block` add the forward view and the block comparison.

#### Can I check risk as well as value?

Yes. `property/flood` and `property/fema_disaster_area` cover flood, and the block hazard components cover earthquake, hail, hurricane, tornado and wind. `property/block_superfund` covers contaminated sites and `property/block_hcri` the provider's housing climate risk indicator.

#### How do I look at a market rather than a property?

Two ways. Set the level to zip, msa, metrodiv or state and pick the components for that level, which give home price and rent indices, affordability and volatility as forecasts and as history. Or use market pulse mode, which reports live listing supply and demand: days on market, list prices, active and new listings, price reductions and months of supply.

#### What happens if a component has no data for an address?

The provider answers HTTP 200 with a per item outcome code, where 204 means it had nothing, and it does not charge for a 204. This actor records each component's outcome separately in `componentStatus`, so a row shows exactly which parts came back. A row where nothing came back at all is stored as a miss with the reasons and is not charged.

#### What happens if my credentials are missing or rejected?

The run ends cleanly with the reason as its status message rather than failing with a stack trace. A missing key, a missing secret, an empty input, credentials the provider will not accept and an exhausted allowance are all treated as answers, not faults. Note that the provider returns a 401 with no explanation, so a wrong key, a wrong secret and a test key used against live data all look identical; the run says so rather than guessing.

#### Are my credentials stored anywhere?

No. They are read from the run input or from the `DATA_API_KEY` and `DATA_API_SECRET` environment secrets, combined into the request's authorization header, and never written to the dataset or the log.

### Example output

```json
{
  "recordType": "property",
  "requested": "10216 N Willow Ave, 64157",
  "found": true,
  "slug": "10216-N-Willow-Ave-Kansas-City-MO-64157",
  "address": "10216 N Willow Ave",
  "city": "Kansas City",
  "state": "MO",
  "postalCode": "64157",
  "estimatedValue": 325000,
  "estimatedValueHigh": 340000,
  "estimatedValueLow": 310000,
  "forecastStandardDeviation": 0.05,
  "estimatedRent": 1800,
  "estimatedRentHigh": 1850,
  "estimatedRentLow": 1750,
  "rentForecastStandardDeviation": 0.08,
  "propertyType": "Single Family Residential",
  "bedrooms": 4,
  "bathrooms": 2.5,
  "totalRooms": 8,
  "buildingAreaSqFt": 2104,
  "lotAreaAcres": 0.23,
  "yearBuilt": 2004,
  "componentStatus": {
    "property/value": "ok",
    "property/rental_value": "ok",
    "property/details": "ok"
  }
}
```

### Keyword map

home value estimate API, AVM API, automated valuation model, property valuation API, house price estimate API, rental estimate API, rent estimate by address, forecast standard deviation, property characteristics API, sales history API, tax history API, home price index API, HPI forecast API, rental price index, affordability index API, housing market data API, days on market data, months of supply, listing supply and demand, flood risk by address, hazard risk data, loan to value API, mortgage lien data, notice of default data, owner occupancy data, real estate analytics API, bulk property valuation

# Actor input Schema

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

A run answers one question. Components reads any combination of the provider's analytics components for a list of properties or geographies in batches of up to a hundred. Version three reads one of the newer single purpose property routes. Market pulse reads listing supply and demand for a place. Fields belonging to another mode are ignored rather than causing an error.

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

Your own account's API key, the user name half of the credential pair, from your account settings. Bring your own key: nothing is shared between runs and the credentials are never written to the dataset or the log.

## `apiSecret` (type: `string`):

Your own account's API secret, the password half of the credential pair. Both halves are required: the provider checks them together and returns no explanation when either is wrong.

## `level` (type: `string`):

What each line of the items list names. Property takes an address, a census block takes a fifteen digit block id, a block group takes twelve digits, a postcode takes five, a metropolitan division and a metropolitan statistical area each take a five digit id, and a state takes a two letter code. The level also decides which components are available, because a component name begins with its own level.

## `items` (type: `array`):

What to read, one per line. At property level write an address followed by a postcode, such as 10216 N Willow Ave, 64157, or an address followed by a city and a two letter state, or the provider's own readable slug. At every other level write the identifier that level takes. A line naming a street with no place is refused with an explanation rather than sent and quietly missed.

## `components` (type: `array`):

Which analytics to read for every item, used by components mode. Each name begins with the level it belongs to, and a component from another level is refused before the first request rather than after it. The provider's rate limit counts components rather than requests, where one component is one endpoint for one item, so four components across a hundred addresses counts as four hundred even though it is one call.

## `v3Target` (type: `string`):

Which of the newer single purpose property routes to read, used by version three mode. Estimate is the fast rounded value, details advanced is the fullest characteristics record, historical value is the value over time, HOA estimate is the modelled association fee, and value FSD threshold reports whether the valuation meets a confidence bar.

## `marketPulseSeries` (type: `string`):

Whether to read the for sale market or the rental market, used by market pulse mode. The rental series is published for metropolitan areas and states but not for postcodes.

## `marketPulseShape` (type: `string`):

Whether to read the latest reading as one row per place, or a time series as one row per period.

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

The earliest period a market pulse time series should cover, written as YYYY-MM-DD. Ignored by every other mode and by the latest shape. For example 2025-01-01.

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

The latest period a market pulse time series should cover, written as YYYY-MM-DD. For example 2026-01-01.

## `batchSize` (type: `integer`):

How many items to send in one batched request, up to the provider's maximum of 100. Fewer, larger batches mean fewer round trips; the provider's rate limit counts components rather than requests, so batching does not change what a run costs against it.

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

The most rows this run may store, and so the most it can charge for. A long market pulse time series produces one row per period per place, so this is the cap that keeps a run predictable.

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

How fast this run calls the provider. The self serve limit is 250 components a minute rather than 250 requests, so lower this when a run asks for many components per item.

## `baseUrl` (type: `string`):

Overrides the API host. Only needed if the provider has given your account a different endpoint.

## Actor input object example

```json
{
  "mode": "components",
  "level": "property",
  "items": [
    "10216 N Willow Ave, 64157"
  ],
  "components": [
    "property/value",
    "property/details"
  ],
  "v3Target": "estimate",
  "marketPulseSeries": "sale",
  "marketPulseShape": "latest",
  "batchSize": 100,
  "maxResults": 100,
  "requestsPerMinute": 30
}
```

# Actor output Schema

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

One row per item, alongside the address or identifier that produced it and the outcome of each component.

# 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 = {
    "items": [
        "10216 N Willow Ave, 64157"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("nabeelbaghoor/home-value-estimate-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 = { "items": ["10216 N Willow Ave, 64157"] }

# Run the Actor and wait for it to finish
run = client.actor("nabeelbaghoor/home-value-estimate-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 '{
  "items": [
    "10216 N Willow Ave, 64157"
  ]
}' |
apify call nabeelbaghoor/home-value-estimate-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nabeelbaghoor/home-value-estimate-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/j9Zv9MQXIdac97R27/builds/xAAoteOdCevMSjCda/openapi.json