# AVM API - Automated Valuation Model for Property Values (`nabeelbaghoor/automated-valuation-model-api`) Actor

Value US residential property with a lending-grade automated valuation model. Get the estimate with its high and low range, forecast standard deviation and confidence score, the comparable sales and listings behind it, and a what-if mode that re-values a home against characteristics you supply.

- **URL**: https://apify.com/nabeelbaghoor/automated-valuation-model-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 $20.00 / 1,000 property valuation 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

## AVM API - Automated Valuation Model for Property Values

Get a lending-grade estimated market value for any US residential property, with the confidence interval and the comparable sales behind it.

### What this actor does

- **Full valuation.** Estimated market value with its low and high bounds, the forecast standard deviation, a confidence score, and the probability the value lands within 5, 10 and 20 percent.
- **Comparable sales and listings.** Every comparable the model reasoned from as its own row: address, coordinates, distance from the subject, size, beds, baths, year built, list price and date, sold price and date.
- **Value only.** Just the number, for pricing a long list cheaply.
- **Interactive what-if.** Re-value a property against the living area, lot size, bedrooms, bathrooms, year built and condition rating you supply, and see what the change is worth.
- **Cascade across models.** Optionally try several lending-grade models in turn to raise the hit rate on properties a single model cannot price. The model that answered is recorded on every row.
- **Backdated values.** Ask for the value as of a past date to audit a decision that was made then.
- **Pay per result.** You are charged for rows that carry a real record. Addresses the provider cannot value are free.

### Bring your own key

This actor calls the provider with **your own API key**, sent in its `x-api-key` header. Paste it into the API key field, or set it as the `DATA_API_KEY` secret. 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": "valuation",
  "requested": "1600 Pennsylvania Ave NW, Washington, DC 20500",
  "found": true,
  "avmId": "1234567",
  "marketValue": 762000,
  "lowValue": 701000,
  "highValue": 823000,
  "forecastStdDev": 0.08,
  "forecastStdDevPercent": 8,
  "confidenceScore": 92,
  "providerName": "Clear Capital",
  "providerModel": "ClearAVM",
  "effectiveDate": "2026-09-01",
  "standardizedAddress": "1600 Pennsylvania Ave NW, Washington, DC 20500",
  "apn": "0143-0001",
  "propertyType": "Single Family Residence",
  "bedrooms": 4,
  "totalBathrooms": 3,
  "livingAreaSqFt": 2450,
  "yearBuilt": 1992,
  "soldComparableCount": 6
}
```

### FAQ

#### What is an AVM?

An automated valuation model estimates what a property is worth from public records, MLS data and recent comparable sales, without anyone visiting it. Lenders, capital markets teams and investors use lending-grade AVMs for prequalification, portfolio monitoring and underwriting support. This actor returns the estimate along with the model's own statement of how confident it is.

#### What is the forecast standard deviation?

The forecast standard deviation, or FSD, is how far the model expects to be off, expressed as a fraction of the value. An FSD of 0.08 means the model expects to land within about eight percent. It is the single most useful number for deciding whether to trust a valuation. This actor stores it both as the raw fraction and as a percentage, and the "maximum forecast standard deviation" input is a fraction between 0 and 1, not a percentage.

#### How accurate is it?

Every valuation row carries the model's own confidence measures: the FSD, a confidence score, an estimated error, and the probability the true value falls within 5, 10 and 20 percent. Accuracy varies by market and by how much recent comparable activity exists, which is exactly what those measures capture. Set a maximum FSD to reject valuations the model is not confident about.

#### Can I see the comparable sales?

Yes. Turn on "Include comparable sales and listings" in full valuation mode and each comparable becomes its own row, with the address, coordinates, straight line distance from the subject property, gross living area, lot size, beds, baths, year built, zoning code, list price and date, and sold price and date.

#### What does the what-if mode do?

Interactive mode re-values a property as if its characteristics were different. Supply a larger living area, an extra bedroom, a later year built or a better condition rating and the model returns the adjusted value alongside the characteristics it started from. It answers questions like what a renovation is worth before you commit to it. Because one set of characteristics is applied to every address in the list, run one property at a time when they differ.

#### Can I get a value as of a past date?

Yes. Set "Value as of date" to a date in YYYY-MM-DD form and the model returns what the property was worth then, which is what you need to audit a lending or purchase decision after the fact. Availability depends on which model answers.

#### What does it cost?

Pricing is pay per result: 0.02 USD per valuation and 0.004 USD per comparable property, with Apify platform usage included. Addresses the provider cannot value are not charged. Retrieving a valuation you already paid for by its id costs nothing extra on the provider's side. You also need your own agreement with the valuation provider, which bills separately.

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

No. A missing key, a rejected key, an exhausted allowance 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

AVM API, automated valuation model API, property valuation API, home value estimate API, house price estimate, real estate appraisal API, lending grade AVM, forecast standard deviation, FSD confidence, comparable sales API, real estate comps API, property value lookup, mortgage collateral valuation, portfolio valuation, retro AVM, backdated property value, what-if property valuation, renovation value estimate, US residential property values, ClearAVM alternative

# Actor input Schema

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

Full runs the lending-grade model and can return the comparables behind it. Value only returns the number alone, which is the cheap way to price a long list. Interactive re-values a property against characteristics you supply. Retrieve fetches a valuation you already paid for by its id.

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

One address per line. Each needs a street address plus either a five digit ZIP or both a city and a two letter state. The ZIP gives the best address match, so include it where you have it.

## `valuationIds` (type: `array`):

Retrieve mode. One valuation id per line, each taken from the avmId column of an earlier run. Retrieving a valuation you already paid for does not run the model again.

## `includeComparables` (type: `boolean`):

Full valuation mode. Returns the comparable properties the model reasoned from, each as its own row with its address, distance from the subject, size, beds, baths, year built, list price and sold price. Without this you get the value and the property characteristics only.

## `tryMultipleModels` (type: `boolean`):

Full valuation mode. Tries several lending-grade models in turn until one returns a value, which raises the hit rate on properties a single model cannot price. The model that answered is recorded on every row. Turning this on disables the confidence ceiling and the data source setting, which apply to a single model only.

## `modelOrder` (type: `array`):

Full valuation mode with the cascade on. Which models to try, in order. Leave empty for the provider's default order. Only models included in your agreement will answer.

## `maxForecastStdDev` (type: `number`):

Full valuation mode without the cascade. The widest error the model may report, as a fraction between 0 and 1 with at most two decimal places. 0.3 means the model must expect to land within about 30 percent. Note this is a fraction, not a percentage. Leave empty for the provider's default of 0.3.

## `dataSourceType` (type: `string`):

Full valuation mode without the cascade. Whether the model may use MLS listing data alongside public records, or public records only. Leave empty for the provider's default, which includes MLS.

## `asOfDate` (type: `string`):

Returns a backdated valuation as of this date, written as YYYY-MM-DD. Useful for auditing a past decision. Availability depends on which model answers.

## `livingAreaSqFt` (type: `integer`):

Interactive mode. The gross living area to value the property at, instead of the one on record.

## `lotSizeSqFt` (type: `integer`):

Interactive mode. The lot size to value the property at, instead of the one on record.

## `bedrooms` (type: `integer`):

Interactive mode. The bedroom count to value the property at, instead of the one on record.

## `fullBathrooms` (type: `integer`):

Interactive mode. The full bathroom count to value the property at.

## `halfBathrooms` (type: `integer`):

Interactive mode. The half bathroom count to value the property at.

## `yearBuilt` (type: `integer`):

Interactive mode. The year built to value the property at, instead of the one on record.

## `condition` (type: `string`):

Interactive mode. The condition to value the property at, on the standard appraisal scale from C1 newly built to C6 substantial damage.

## `savePdf` (type: `boolean`):

Full valuation mode. Asks the provider to store the valuation and return a link to a PDF report, which appears in the pdfLink column. The provider may charge extra for stored results.

## `trackingIds` (type: `array`):

Optional. Up to three of your own reference ids, echoed back on every valuation so you can tie results to a loan file or an order. One per line.

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

The most rows this run will save and charge for. Comparables count towards this, and a full valuation can return many, so allow room when they are turned on.

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

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

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

Your own API key for the valuation provider. This actor is bring your own key: it never uses anyone else's credentials, and the key is stored as a secret and sent in the provider's x-api-key header.

## Actor input object example

```json
{
  "mode": "full",
  "includeComparables": true,
  "tryMultipleModels": false,
  "savePdf": false,
  "maxResults": 500,
  "requestsPerMinute": 60
}
```

# Actor output Schema

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

One row per record, alongside the address or valuation id 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/automated-valuation-model-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/automated-valuation-model-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/automated-valuation-model-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nabeelbaghoor/automated-valuation-model-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/l6YagVCI46hdMtnf0/builds/YuY7ziXZ663NGUqA8/openapi.json