# Realtor.com Market Data Scraper — Hotness, Forecast, Schools (`sian.agency/realtor-market-analytics-scraper`) Actor

Extract US housing market data from Realtor.com map layers: ZIP market hotness scores, 12-month price forecasts, days-on-market and home-value heatmaps, parcel-level estimates, flood and wildfire climate risk, school ratings. One query per metro returns hundreds of analyst-ready rows.

- **URL**: https://apify.com/sian.agency/realtor-market-analytics-scraper.md
- **Developed by:** [SIÁN OÜ](https://apify.com/sian.agency) (community)
- **Categories:** Real estate, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.00 / 1,000 map layer queries

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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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.com Market Data Scraper — Housing Market Intelligence 🚀

[![SIÁN Agency Store](https://img.shields.io/badge/Store-SI%C3%81N%20Agency-1AE392)](https://apify.com/sian.agency?fpr=sian) [![Realtor.com Property Scraper](https://img.shields.io/badge/Store-Realtor.com%20Property%20Scraper-D92228)](https://apify.com/sian.agency/realtor-property-scraper?fpr=sian) [![Realtor.com Agent Scraper](https://img.shields.io/badge/Store-Realtor.com%20Agent%20Scraper-D92228)](https://apify.com/sian.agency/realtor-agent-scraper?fpr=sian) [![Zillow Market Data Scraper](https://img.shields.io/badge/Store-Zillow%20Market%20Data%20Scraper-1F4E79)](https://apify.com/sian.agency/zillow-market-analytics-scraper?fpr=sian)

#### 🎉 Every ZIP in a metro, scored and forecast in one query — 345 hotness-scored ZIPs and ~4,500 home-value heatmap cells per call
##### Built for real-estate investors, PropTech data teams, and market analysts who need housing market data, not listings

---

### 📋 Overview

**Stop stitching together housing market data from blogs and PDFs** — this actor pulls Realtor.com's market-intelligence map layers as clean, analyst-ready dataset rows: ZIP-level market hotness scores, 12-month home-price forecasts, days-on-market and home-value heatmaps, parcel-level estimates, climate-risk overlays, and school ratings for any US location.

**Why data teams choose us:**
- ✅ **ZIP-level Market Hotness**: every ZIP in a metro scored + labeled (345 ZIP rows for a single "Austin, TX" query)
- ⚡ **12-Month Price Forecasts**: forecast home value in dollars AND percent change, per ZIP — feed buy-box models directly
- 🎯 **~4,500 Heatmap Cells per Query**: home-value estimates, $/sqft, days on market, year built, lot data, noise scores
- 💰 **Priced per query, not per row**: one metro-wide layer costs about a cent — hundreds to thousands of rows per charge
- 💎 **Parcel Mode (zoom 16)**: per-parcel value estimates with the real property IDs behind every cell, ready for detail enrichment
- ✨ **NEW**: climate-risk raster overlays (flood, wildfire, heat, wind, air) with 0/15/30-year projections stored as ready-to-use PNG tiles

---

### ✨ Features

- 🔥 **Market Hotness Layer**: demand score (0–100) + Hot/Warm/Cool label for every ZIP in the resolved region
- 📈 **Housing Forecast Layer**: 12-month forecast home value ($) and percentage change per ZIP
- 🗺️ **10 Heatmap Layers**: Estimate, $/sqft, Sqft, YearBuilt, LotAcres, LotSlope, Noise, DaysOnMarket, Sold-vs-List, Sold $/sqft
- 🏠 **Parcel Resolution**: zoom 15–16 unlocks per-parcel estimates + property-ID join keys
- 🌊 **Climate Risk Overlays**: flood, wildfire, heat, wind, and air-quality rasters with selectable projection horizon (today / +15y / +30y)
- 🏫 **Schools Layer**: every school + district in the region with ratings, parent ratings, student-teacher ratios, phone, and website
- 🏘️ **Neighborhoods Layer**: neighborhood names with stable slug/geo IDs for downstream joins
- 📍 **Free-Form Locations**: ZIP, city, neighborhood, county, or full address — resolved automatically
- 📊 **Analyst-Ready Rows**: flat, typed fields that drop straight into BigQuery, Snowflake, pandas, or Sheets

---

### 🎬 Quick Start

Pick one or more US locations, choose your layers, and run — each location × layer pair returns its complete result set as dataset rows.

```bash
curl -X POST https://api.apify.com/v2/acts/sian.agency~realtor-market-analytics-scraper/runs?token=YOUR_TOKEN \
-H 'Content-Type: application/json' \
-d '{"locations": ["Austin, TX"], "layers": ["MarketHotness", "HousingForecast", "DaysOnMarket"]}'
````

***

### 🚀 Getting Started (3 Simple Steps)

#### Step 1: Enter locations

Add one or more US locations — `78704`, `Austin, TX`, `Travis County`, or a full address.

#### Step 2: Pick your layers

Choose from 19 market-data layers: ZIP metrics, heatmaps, climate rasters, schools, neighborhoods.

#### Step 3: Run and export

Click Start. Export the dataset as JSON, CSV, or Excel — or read it via the API.

**That's it! In under a minute, you'll have:**

- Every ZIP in your market scored and forecast
- Heatmap cells with home values and market velocity
- School ratings and climate-risk overlays for due diligence

***

### 📥 Input Configuration

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| locations | array | Yes | US locations — ZIP, city (`Austin, TX`), neighborhood, county, or address |
| layers | array | No | Layers to fetch per location (default: MarketHotness, HousingForecast, DaysOnMarket) |
| zoom | integer | No | Map zoom 3–16. 15–16 = parcel resolution on heatmap layers (PAID) |
| relativeYear | string | No | Climate projection horizon for raster layers: `0`, `15`, or `30` years |

**Example:**

```json
{
  "locations": ["Austin, TX", "Miami, FL"],
  "layers": ["MarketHotness", "HousingForecast", "Schools"]
}
```

**Parcel-resolution example (PAID):**

```json
{
  "locations": ["78704"],
  "layers": ["Estimate"],
  "zoom": 16
}
```

***

### 📤 Output

Results are saved to the Apify dataset with **45+ fields** across row types (`zipMetric`, `heatmapCell`, `parcelCell`, `neighborhood`, `school`, `district`, `rasterTileSet`):

| Field | Type | Description |
|-------|------|-------------|
| rowType | string | Shape of the row (zipMetric, heatmapCell, parcelCell, school, …) |
| layer | string | Layer that produced the row (MarketHotness, Estimate, Flood, …) |
| postalCode | string | ZIP code join key for zipMetric rows |
| hotnessScore | number | Market hotness score (0–100) |
| hotnessLabel | string | Hot / Warm / Cool band |
| forecastAmount | number | 12-month forecast home value (USD) |
| forecastPercentage | number | 12-month forecast change (%) |
| metricName | string | Heatmap cell metric (estimate, daysOnMarket365, yearBuilt, …) |
| metricValue | number | Cell metric value |
| homeCount | integer | Homes aggregated into the cell |
| propertyIds | array | Property IDs behind a parcel cell (zoom 15+) |
| schoolName | string | School name with rating, parent rating, contacts |
| rating | number | School/district quality rating (1–10) |
| tiles | array | Climate raster tile manifest with stored PNG URLs |
| latitude / longitude | number | Coordinates for mapping |

**Example (zipMetric row):**

```json
{
  "rowType": "zipMetric",
  "layer": "MarketHotness",
  "locationQuery": "Austin, TX",
  "regionName": "Austin, TX",
  "areaType": "city",
  "postalCode": "76844",
  "hotnessScore": 11.43,
  "hotnessLabel": "Cool",
  "latitude": 31.4395,
  "longitude": -98.4945,
  "fetchedAt": "2026-07-02T07:34:57.211Z"
}
```

***

### 💼 Use Cases & Examples

#### 1. ZIP Hotness Screening for Investors

**Real-estate investors rank every ZIP in a metro before running comps.**

**Input:** `["Austin, TX"]` + `MarketHotness`
**Output:** 345 ZIP rows with hotness score + label
**Use:** Shortlist the hottest submarkets, then feed the ZIPs into listing scrapers.

#### 2. 12-Month Price Forecast Feeds

**Acquisition analysts load forecast home values into buy-box models.**

**Input:** Target metros + `HousingForecast`
**Output:** Forecast $ and % change per ZIP
**Use:** Refresh market-timing dashboards weekly without manual data pulls.

#### 3. Valuation Heatmaps for PropTech Apps

**Product teams render home-value and days-on-market heatmaps in their own UI.**

**Input:** ZIPs + `Estimate` / `DaysOnMarket` layers
**Output:** ~4,500 hex cells per query with coordinates and values
**Use:** Power map visualizations without building a data pipeline.

#### 4. Parcel-Level Lead Sourcing

**Investors and wholesalers find the properties behind hot cells.**

**Input:** ZIP + `Estimate` + `zoom: 16`
**Output:** Per-parcel estimates with real property IDs
**Use:** Join the IDs into a property-detail scraper for owner and listing data.

#### 5. Climate-Risk Due Diligence

**Underwriters and insurers overlay flood and wildfire risk on any market.**

**Input:** `["Miami, FL"]` + `Flood` + `relativeYear: "30"`
**Output:** PNG overlay tiles (stored in the run's key-value store) + manifest row
**Use:** Compare today's risk against 30-year projections for portfolio screening.

#### 6. School-Quality Overlays for Relocation Tools

**Relocation platforms and brokerages attach school data to every listing.**

**Input:** City + `Schools`
**Output:** 200+ schools and districts with ratings, ratios, phone, website
**Use:** Enrich listing pages and relocation reports with trusted school data.

***

### 🔗 Integration Examples

#### JavaScript/Node.js

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });

const run = await client.actor('sian.agency/realtor-market-analytics-scraper').call({
  locations: ['Austin, TX'],
  layers: ['MarketHotness', 'HousingForecast']
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0]);
```

#### Python

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_TOKEN')

run = client.actor('sian.agency/realtor-market-analytics-scraper').call(
    run_input={'locations': ['Austin, TX'], 'layers': ['MarketHotness', 'HousingForecast']}
)

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item)
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/sian.agency~realtor-market-analytics-scraper/runs?token=YOUR_TOKEN' \
-H 'Content-Type: application/json' \
-d '{"locations": ["Austin, TX"], "layers": ["MarketHotness"]}'
```

#### Automation Workflows (N8N / Zapier / Make)

1. **Trigger**: Weekly schedule
2. **HTTP Request**: Call the actor API with your watch-list metros
3. **Process**: Filter ZIPs by hotness score or forecast change
4. **Action**: Push to BigQuery, Sheets, or Slack alerts

***

### 📊 Performance & Pricing

#### FREE Tier (Try It Now)

- **1 location × 3 layers** per run — full data quality, hundreds of rows
- No credit card required
- Perfect for evaluating a single market

#### PAID Tier (Production Ready)

- **Unlimited locations and all 19 layers** per run
- Parcel-resolution zoom (15–16) with property-ID join keys
- Pay-per-query: one charge per successful location × layer fetch — failures and empty results are never charged

💰 **A whole metro's market data for about a cent per layer** — one query returns 150–4,500 rows, instead of paying per row.

🔗 [View current pricing](https://apify.com/sian.agency/realtor-market-analytics-scraper?fpr=sian)

***

### ❓ Frequently Asked Questions

**Q: What locations are supported?**
A: Any US location — ZIP code, city (`Austin, TX`), neighborhood, county, or full street address. The region is resolved automatically and echoed back as `regionName`.

**Q: How many rows does one query return?**
A: Depends on the layer: ~250–350 ZIP rows for hotness/forecast, ~4,500 cells for heatmap layers, 200+ schools for a city, 1 manifest row + 9 PNG tiles for climate layers.

**Q: What is parcel mode?**
A: Setting `zoom` to 15–16 on heatmap layers switches to parcel resolution: each cell carries a per-parcel value estimate and the real property IDs behind it (PAID tier).

**Q: How do I get the climate overlay images?**
A: Raster tiles are decoded and stored as PNG files in the run's key-value store; the dataset row contains a manifest with a direct URL per tile.

**Q: What output formats are available?**
A: JSON, CSV, Excel — export directly from the Apify dataset.

**Q: Is this legal?**
A: Yes — we only extract publicly available data. See the [legal section](#%EF%B8%8F-is-it-legal-to-scrape-data) below.

**Q: How long does a run take?**
A: A few seconds per layer query — 5 layers for a metro completes in under 30 seconds.

***

### 🐛 Troubleshooting

**"Location not found" error**

- Use a more specific location: add the state (`Austin, TX` instead of `Austin`) or use a ZIP code.

**Heatmap rows have null metric values**

- Sparse cells (few homes) sometimes omit the metric — filter on `metricValue IS NOT NULL`.

**Parcel mode returns standard cells**

- Parcel resolution requires `zoom` 15–16 AND a PAID plan; the FREE tier falls back to the default zoom.

**Hotness score is null for some ZIPs**

- Rural ZIPs without enough transactions are unscored upstream; the row still carries the ZIP and coordinates.

***

### ⚠️ Trademark Disclaimer

Realtor.com® is a registered trademark of Move, Inc. This actor is an independent tool and is **not affiliated with, endorsed by, or sponsored by Move, Inc. or Realtor.com**. All trademarks, service marks, and company names are the property of their respective owners. The actor only accesses publicly available data.

***

### ⚖️ Is it legal to scrape data?

Our actors are ethical and do not extract any private user data, such as email addresses, gender, or location. 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

[![Telegram Support](https://img.shields.io/badge/Telegram-Support%20Group-0088cc?logo=telegram)](https://t.me/+vyh1sRE08sAxMGRi)

**Join our active support community**

- For issues or questions, open an issue in the actor's repository
- Check [SIÁN Agency Store](https://apify.com/sian.agency?fpr=sian) for more automation tools
- 📧 <apify@sian-agency.online>

***

**Built by [SIÁN Agency](https://www.sian-agency.online)** | **[More Tools](https://apify.com/sian.agency?fpr=sian)**

# Actor input Schema

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

US locations to analyze — ZIP code (`78704`), city (`Austin, TX`), neighborhood, county, or full address. Each location is resolved server-side and every selected layer is fetched for it. **FREE tier:** 1 location per run.

## `layers` (type: `array`):

Which map-data layers to fetch per location. **ZIP metrics:** MarketHotness (hotness score + label per ZIP), HousingForecast (12-month forecast $ and %). **Heatmap cells (~4,500/ZIP query):** Estimate, EstimatePpsqft, Sqft, YearBuilt, LotAcres, LotSlope, Noise, DaysOnMarket, SoldPriceVsListPrice, SoldSqft. **Climate rasters (PNG overlays):** Flood, Wildfire, Heat, Wind, Air. **Records:** Schools (ratings + contacts), Neighborhoods (names + region IDs). **FREE tier:** up to 3 layers per run.

## `zoom` (type: `integer`):

Optional map zoom (3–16). Leave empty for each layer's sensible default. **Zoom 15–16 on heatmap layers switches to parcel resolution** — per-parcel value estimates plus the property IDs behind every cell (PAID tier, billed as parcel queries).

## `relativeYear` (type: `string`):

Projection horizon for climate raster layers (Flood, Wildfire, Heat, Wind, Air): 0 = today, 15 = +15 years, 30 = +30 years. Ignored by non-climate layers.

## Actor input object example

```json
{
  "locations": [
    "Austin, TX",
    "78704",
    "Miami, FL"
  ],
  "layers": [
    "MarketHotness",
    "HousingForecast",
    "DaysOnMarket"
  ],
  "relativeYear": "0"
}
```

# Actor output Schema

## `results` (type: `string`):

One row per ZIP metric, heatmap cell, parcel cell, neighborhood, school, district, or climate tile set.

## `htmlReport` (type: `string`):

HTML dashboard summarizing per-query and per-layer row counts.

# 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"
    ],
    "layers": [
        "MarketHotness",
        "HousingForecast",
        "DaysOnMarket"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("sian.agency/realtor-market-analytics-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"],
    "layers": [
        "MarketHotness",
        "HousingForecast",
        "DaysOnMarket",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("sian.agency/realtor-market-analytics-scraper").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 '{
  "locations": [
    "Austin, TX"
  ],
  "layers": [
    "MarketHotness",
    "HousingForecast",
    "DaysOnMarket"
  ]
}' |
apify call sian.agency/realtor-market-analytics-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Realtor.com Market Data Scraper — Hotness, Forecast, Schools",
        "description": "Extract US housing market data from Realtor.com map layers: ZIP market hotness scores, 12-month price forecasts, days-on-market and home-value heatmaps, parcel-level estimates, flood and wildfire climate risk, school ratings. One query per metro returns hundreds of analyst-ready rows.",
        "version": "1.0",
        "x-build-id": "sioXJLdZKlvSCqtvT"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sian.agency~realtor-market-analytics-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sian.agency-realtor-market-analytics-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/sian.agency~realtor-market-analytics-scraper/runs": {
            "post": {
                "operationId": "runs-sync-sian.agency-realtor-market-analytics-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/sian.agency~realtor-market-analytics-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-sian.agency-realtor-market-analytics-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "locations"
                ],
                "properties": {
                    "locations": {
                        "title": "📍 Locations",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "US locations to analyze — ZIP code (`78704`), city (`Austin, TX`), neighborhood, county, or full address. Each location is resolved server-side and every selected layer is fetched for it. **FREE tier:** 1 location per run.",
                        "default": [
                            "Austin, TX"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "layers": {
                        "title": "🗂️ Market data layers",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Which map-data layers to fetch per location. **ZIP metrics:** MarketHotness (hotness score + label per ZIP), HousingForecast (12-month forecast $ and %). **Heatmap cells (~4,500/ZIP query):** Estimate, EstimatePpsqft, Sqft, YearBuilt, LotAcres, LotSlope, Noise, DaysOnMarket, SoldPriceVsListPrice, SoldSqft. **Climate rasters (PNG overlays):** Flood, Wildfire, Heat, Wind, Air. **Records:** Schools (ratings + contacts), Neighborhoods (names + region IDs). **FREE tier:** up to 3 layers per run.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "MarketHotness",
                                "HousingForecast",
                                "DaysOnMarket",
                                "Estimate",
                                "EstimatePpsqft",
                                "Sqft",
                                "YearBuilt",
                                "LotAcres",
                                "LotSlope",
                                "Noise",
                                "SoldPriceVsListPrice",
                                "SoldSqft",
                                "Neighborhoods",
                                "Schools",
                                "Flood",
                                "Wildfire",
                                "Heat",
                                "Wind",
                                "Air"
                            ],
                            "enumTitles": [
                                "Market Hotness (score per ZIP)",
                                "Housing Forecast (12-month $ + % per ZIP)",
                                "Days on Market (heatmap cells)",
                                "Home Value Estimate (heatmap cells)",
                                "Estimate $/sqft (heatmap cells)",
                                "Home Size sqft (heatmap cells)",
                                "Year Built (heatmap cells)",
                                "Lot Acres (heatmap cells)",
                                "Lot Slope (heatmap cells)",
                                "Noise Score (heatmap cells)",
                                "Sold vs List Price (heatmap cells)",
                                "Sold $/sqft (heatmap cells)",
                                "Neighborhoods (names + region IDs)",
                                "Schools (ratings + contacts)",
                                "Flood Risk (raster overlay)",
                                "Wildfire Risk (raster overlay)",
                                "Heat Risk (raster overlay)",
                                "Wind Risk (raster overlay)",
                                "Air Quality (raster overlay)"
                            ]
                        },
                        "default": [
                            "MarketHotness",
                            "HousingForecast",
                            "DaysOnMarket"
                        ]
                    },
                    "zoom": {
                        "title": "🔎 Zoom level",
                        "minimum": 3,
                        "maximum": 16,
                        "type": "integer",
                        "description": "Optional map zoom (3–16). Leave empty for each layer's sensible default. **Zoom 15–16 on heatmap layers switches to parcel resolution** — per-parcel value estimates plus the property IDs behind every cell (PAID tier, billed as parcel queries)."
                    },
                    "relativeYear": {
                        "title": "🌡️ Climate projection horizon",
                        "enum": [
                            "0",
                            "15",
                            "30"
                        ],
                        "type": "string",
                        "description": "Projection horizon for climate raster layers (Flood, Wildfire, Heat, Wind, Air): 0 = today, 15 = +15 years, 30 = +30 years. Ignored by non-climate layers.",
                        "default": "0"
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
