Data is transforming the real estate industry. Investors, agents, and proptech companies use analytics dashboards to track price trends, compare neighborhoods, and identify opportunities before the competition.
But most real estate data tools are expensive and inflexible. In this tutorial, you'll learn how to build your own analytics dashboard from scratch — fetching data from a real estate API, processing it with Python, and visualizing it with Chart.js.
The skills you'll learn here apply beyond real estate. The same data pipeline pattern — collect, process, store, visualize — is used in finance, e-commerce, and any data-driven field.
The Data Pipeline
Every analytics dashboard follows the same four-step pipeline. Understanding this architecture is key to building a system that scales:
Step 1: Fetch Market Data
The first step is collecting raw data. Real estate APIs return listings with prices, square footage, bedrooms, and other attributes. We'll aggregate this data into meaningful market statistics.
import requests
import os
from datetime import datetime
def fetch_market_data(city, state):
"""Fetch listings and calculate market statistics."""
api_key = os.environ["API_KEY"]
response = requests.get(
f"{os.environ['API_URL']}/search",
headers={"X-API-Key": api_key},
params={
"city": city,
"state_code": state,
"status": "for_sale",
"limit": 200,
"sort": "list_date"
},
timeout=15
)
response.raise_for_status()
listings = response.json()["data"]["results"]
# Calculate market metrics
prices = [l["list_price"] for l in listings if l.get("list_price")]
sqft_prices = [
l["list_price"] / l["sqft"]
for l in listings
if l.get("list_price") and l.get("sqft") and l["sqft"] > 0
]
if not prices:
return None
prices.sort()
return {
"city": city,
"state": state,
"date": datetime.now().strftime("%Y-%m-%d"),
"total_listings": len(listings),
"median_price": prices[len(prices) // 2],
"avg_price": round(sum(prices) / len(prices)),
"min_price": prices[0],
"max_price": prices[-1],
"avg_price_sqft": round(sum(sqft_prices) / len(sqft_prices)) if sqft_prices else 0
}Step 2: Store Data Over Time
To show trends, you need historical data. SQLite is perfect for this — zero setup, file-based, and handles analytics queries well:
import sqlite3
def init_db():
"""Create the database and table if they don't exist."""
conn = sqlite3.connect("market_data.db")
conn.execute("""
CREATE TABLE IF NOT EXISTS snapshots (
id INTEGER PRIMARY KEY AUTOINCREMENT,
city TEXT NOT NULL,
state TEXT NOT NULL,
date TEXT NOT NULL,
total_listings INTEGER,
median_price INTEGER,
avg_price INTEGER,
min_price INTEGER,
max_price INTEGER,
avg_price_sqft INTEGER,
UNIQUE(city, state, date)
)
""")
conn.commit()
return conn
def save_snapshot(conn, data):
"""Save a market snapshot. Skip if today's data already exists."""
try:
conn.execute(
"""INSERT INTO snapshots
(city, state, date, total_listings, median_price,
avg_price, min_price, max_price, avg_price_sqft)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)""",
(data["city"], data["state"], data["date"],
data["total_listings"], data["median_price"],
data["avg_price"], data["min_price"],
data["max_price"], data["avg_price_sqft"])
)
conn.commit()
except sqlite3.IntegrityError:
pass # Already have today's data
def get_trends(conn, city, state, days=90):
"""Get historical trends for a city."""
cursor = conn.execute(
"""SELECT date, median_price, total_listings, avg_price_sqft
FROM snapshots
WHERE city = ? AND state = ?
ORDER BY date DESC
LIMIT ?""",
(city, state, days)
)
return cursor.fetchall()Step 3: Compare Multiple Markets
The real power of analytics comes from comparison. Here's how to fetch and compare data across multiple cities:
def compare_markets(markets):
"""Fetch and compare data for multiple markets."""
results = {}
for city, state in markets:
data = fetch_market_data(city, state)
if data:
results[f"{city}, {state}"] = data
# Print comparison table
print(f"\n{'Market':<20} {'Median':<14} {'$/sqft':<10} {'Listings':<10}")
print("-" * 54)
for market, stats in results.items():
print(f"{market:<20} ${stats['median_price']:>10,} "
f"${stats['avg_price_sqft']:>6,} "
f"{stats['total_listings']:>8}")
return results
# Example usage
markets = [
("Austin", "TX"),
("Denver", "CO"),
("Phoenix", "AZ"),
("Nashville", "TN"),
("Raleigh", "NC")
]
compare_markets(markets)Step 4: Build the Dashboard Frontend
Use Chart.js to create interactive charts. Here's a price trend chart that updates dynamically:
async function renderPriceTrend(city, state) {
const response = await fetch(
`/api/trends?city=${city}&state=${state}`
);
const data = await response.json();
const ctx = document.getElementById('priceChart').getContext('2d');
new Chart(ctx, {
type: 'line',
data: {
labels: data.dates,
datasets: [{
label: 'Median Price',
data: data.median_prices,
borderColor: '#3B82F6',
backgroundColor: 'rgba(59, 130, 246, 0.1)',
fill: true,
tension: 0.3
}]
},
options: {
responsive: true,
plugins: {
legend: { display: true }
},
scales: {
y: {
ticks: {
callback: value =>
'$' + value.toLocaleString()
}
}
}
}
});
}
async function renderInventoryChart(city, state) {
const response = await fetch(
`/api/trends?city=${city}&state=${state}`
);
const data = await response.json();
const ctx = document.getElementById('inventoryChart').getContext('2d');
new Chart(ctx, {
type: 'bar',
data: {
labels: data.dates,
datasets: [{
label: 'Active Listings',
data: data.listings,
backgroundColor: '#FFC91F'
}]
},
options: {
responsive: true,
scales: {
y: { beginAtZero: true }
}
}
});
}Key Metrics to Track
Not all metrics are equally useful. Focus on these core indicators that real estate professionals actually use:
| Metric | What It Tells You | How to Calculate |
|---|---|---|
| Median Price | Central tendency of the market | Middle value of sorted prices |
| Price per Sqft | Normalized price for fair comparison | Price / square footage |
| Inventory Count | Supply level (buyer vs seller market) | Count of active listings |
| Days on Market | How quickly homes are selling | Average days from list to sale |
| Price Change % | Direction and speed of price movement | (Current - Previous) / Previous |
| List-to-Sale Ratio | How close homes sell to asking price | Sale price / list price |
What to Do Next
You now have a complete data pipeline — from API to database to chart. Here are ways to extend it:
- Automate collection — Use
cronor a task scheduler to fetch data daily - Add alerts — Notify yourself when a metric changes significantly (e.g., prices drop 5%+)
- Build neighborhood scoring — Combine multiple metrics into a single investment score
- Export reports — Generate PDF or CSV reports for clients or stakeholders
- Add more data sources — Combine property data with census, school, and crime data for richer analysis
The pattern you've learned here — collect, process, store, visualize — is the foundation of any data analytics system. Master it once and you can apply it to any domain.
