Building a Real Estate Price Comparison Tool with BayutAPI

One of the most powerful applications of real estate data is price comparison. Investors, homebuyers, and analysts all want to answer the same fundamental question: where do I get the best value for my money?

In this tutorial, we will build a Python tool that compares average property prices across multiple Dubai neighborhoods, calculates price per square foot, and presents the data in a clear, actionable format.

What We’re Building

Our price comparison tool will:

1. Take a list of Dubai neighborhoods as input
2. Fetch property listings for each neighborhood
3. Calculate average price, average price per square foot, and price ranges
4. Output a comparison table sorted by value

Setup

You will need Python 3.9+ and the requests library:

pip install requests

The API Client

First, let’s create a focused API client for our price comparison use case:

import requests
from dataclasses import dataclass

API_URL = "https://bayut14.p.rapidapi.com/v2"
HEADERS = {
    "x-rapidapi-host": "bayut14.p.rapidapi.com",
    "x-rapidapi-key": "YOUR_API_KEY"
}


@dataclass
class AreaStats:
    name: str
    location_id: str
    listing_count: int
    avg_price: float
    median_price: float
    min_price: int
    max_price: int
    avg_price_per_sqft: float
    avg_area: float


def get_location_id(name: str) -> str | None:
    """Resolve a location name to its ID."""
    response = requests.get(
        f"{API_URL}/autocomplete",
        headers=HEADERS,
        params={"query": name, "purpose": "for-sale"}
    )
    response.raise_for_status()
    locations = response.json().get("data", {}).get("locations", [])
    if locations:
        return locations[0].get("externalID")
    return None


def fetch_listings(
    location_id: str,
    purpose: str = "for-sale",
    category: str = "apartments",
    rooms: int | None = None,
    pages: int = 3
) -> list[dict]:
    """Fetch multiple pages of listings for a location."""
    all_listings = []

    for page in range(1, pages + 1):
        params = {
            "location_ids": location_id,
            "purpose": purpose,
            "property_type": category,
            "page": str(page),
            "sort": "latest"
        }
        if rooms is not None:
            params["rooms"] = str(rooms)

        response = requests.get(
            f"{API_URL}/properties",
            headers=HEADERS,
            params=params
        )
        response.raise_for_status()
        data = response.json()
        properties = data.get("data", {}).get("properties", [])
        if not properties:
            break
        all_listings.extend(properties)

    return all_listings

Computing Area Statistics

Now the core analysis function that computes statistics for each neighborhood:

from statistics import median


def compute_stats(name: str, location_id: str, listings: list[dict]) -> AreaStats:
    """Compute price statistics for a set of listings."""
    # Filter out listings with missing or zero values
    valid = [
        prop for prop in listings
        if prop.get("price", 0) > 0 and prop.get("area", 0) > 0
    ]

    if not valid:
        return AreaStats(
            name=name, location_id=location_id,
            listing_count=0, avg_price=0, median_price=0,
            min_price=0, max_price=0, avg_price_per_sqft=0, avg_area=0
        )

    prices = [p["price"] for p in valid]
    areas = [p["area"] for p in valid]
    price_per_sqft = [p["price"] / p["area"] for p in valid]

    return AreaStats(
        name=name,
        location_id=location_id,
        listing_count=len(valid),
        avg_price=sum(prices) / len(prices),
        median_price=median(prices),
        min_price=min(prices),
        max_price=max(prices),
        avg_price_per_sqft=sum(price_per_sqft) / len(price_per_sqft),
        avg_area=sum(areas) / len(areas)
    )

The Comparison Engine

Here is the main comparison function that ties everything together:

def compare_areas(
    area_names: list[str],
    purpose: str = "for-sale",
    category: str = "apartments",
    rooms: int | None = None
) -> list[AreaStats]:
    """Compare property prices across multiple areas."""
    results = []

    for area_name in area_names:
        print(f"Fetching data for {area_name}...")

        location_id = get_location_id(area_name)
        if not location_id:
            print(f"  Could not find location: {area_name}")
            continue

        listings = fetch_listings(
            location_id=location_id,
            purpose=purpose,
            category=category,
            rooms=rooms
        )

        stats = compute_stats(area_name, location_id, listings)
        results.append(stats)
        print(f"  Found {stats.listing_count} listings")

    # Sort by average price per sqft (best value first)
    results.sort(key=lambda s: s.avg_price_per_sqft if s.avg_price_per_sqft > 0 else float('inf'))
    return results


def print_comparison(results: list[AreaStats], rooms: int | None = None) -> None:
    """Print a formatted comparison table."""
    bedroom_label = f"{rooms}BR" if rooms else "All"

    print(f"\n{'='*80}")
    print(f"  Price Comparison — {bedroom_label} Apartments (Sorted by Price/sqft)")
    print(f"{'='*80}\n")

    print(f"{'Area':<25} {'Listings':>8} {'Avg Price':>14} {'Avg $/sqft':>12} {'Avg Size':>10}")
    print(f"{'-'*25} {'-'*8} {'-'*14} {'-'*12} {'-'*10}")

    for stats in results:
        if stats.listing_count == 0:
            print(f"{stats.name:<25} {'No data':>8}")
            continue

        print(
            f"{stats.name:<25} "
            f"{stats.listing_count:>8} "
            f"{'AED {:,.0f}'.format(stats.avg_price):>14} "
            f"{'AED {:,.0f}'.format(stats.avg_price_per_sqft):>12} "
            f"{stats.avg_area:>9.0f}ft"
        )

    print(f"\n{'='*80}")

    # Price range details
    print(f"\n  Price Ranges:\n")
    for stats in results:
        if stats.listing_count == 0:
            continue
        print(
            f"  {stats.name}: "
            f"AED {stats.min_price:,.0f} — AED {stats.max_price:,.0f} "
            f"(median: AED {stats.median_price:,.0f})"
        )

Running the Comparison

Put it all together in a main script:

if __name__ == "__main__":
    # Compare popular Dubai neighborhoods for 2BR apartments
    areas = [
        "Dubai Marina",
        "Downtown Dubai",
        "Jumeirah Village Circle",
        "Business Bay",
        "Dubai Hills Estate",
        "Jumeirah Lake Towers",
        "Palm Jumeirah",
        "Dubai Silicon Oasis"
    ]

    results = compare_areas(areas, purpose="for-sale", category="apartments", rooms=2)
    print_comparison(results, rooms=2)

Running this produces output like:

Fetching data for Dubai Marina...
  Found 75 listings
Fetching data for Downtown Dubai...
  Found 68 listings
...

================================================================================
  Price Comparison — 2BR Apartments (Sorted by Price/sqft)
================================================================================

Area                     Listings      Avg Price   Avg $/sqft   Avg Size
------------------------- -------- -------------- ------------ ----------
Dubai Silicon Oasis            42    AED 750,000    AED 620       1210ft
Jumeirah Village Circle        71    AED 1,150,000  AED 785       1465ft
Jumeirah Lake Towers           58    AED 1,380,000  AED 920       1500ft
Business Bay                   64    AED 1,650,000  AED 1,150     1435ft
Dubai Hills Estate             55    AED 1,850,000  AED 1,280     1445ft
Dubai Marina                   75    AED 1,920,000  AED 1,350     1422ft
Downtown Dubai                 68    AED 2,450,000  AED 1,680     1458ft
Palm Jumeirah                  39    AED 3,850,000  AED 2,150     1790ft

================================================================================

  Price Ranges:

  Dubai Silicon Oasis: AED 480,000 — AED 1,200,000 (median: AED 720,000)
  Jumeirah Village Circle: AED 680,000 — AED 1,800,000 (median: AED 1,100,000)
  ...

Extending the Tool

Add Time-Based Comparison

Track how prices change over time by running the comparison weekly and storing results:

import json
from datetime import date

def save_snapshot(results: list[AreaStats]) -> None:
    """Save a price snapshot for historical tracking."""
    snapshot = {
        "date": date.today().isoformat(),
        "areas": [
            {
                "name": s.name,
                "avg_price": s.avg_price,
                "avg_price_per_sqft": s.avg_price_per_sqft,
                "listing_count": s.listing_count
            }
            for s in results
        ]
    }

    filename = f"snapshots/price_snapshot_{date.today().isoformat()}.json"
    with open(filename, "w") as f:
        json.dump(snapshot, f, indent=2)

Add Rental Comparison

Compare rental prices alongside sale prices to identify areas with the best rental yields:

sale_results = compare_areas(areas, purpose="for-sale", category="apartments", rooms=2)
rent_results = compare_areas(areas, purpose="for-rent", category="apartments", rooms=2)

for sale, rent in zip(sale_results, rent_results):
    if sale.avg_price > 0 and rent.avg_price > 0:
        gross_yield = (rent.avg_price / sale.avg_price) * 100
        print(f"{sale.name}: {gross_yield:.1f}% gross rental yield")

Export to CSV

For further analysis in spreadsheets or data tools:

import csv

def export_csv(results: list[AreaStats], filename: str = "comparison.csv") -> None:
    with open(filename, "w", newline="") as f:
        writer = csv.writer(f)
        writer.writerow([
            "Area", "Listings", "Avg Price", "Median Price",
            "Min Price", "Max Price", "Avg Price/sqft", "Avg Area"
        ])
        for s in results:
            writer.writerow([
                s.name, s.listing_count, f"{s.avg_price:.0f}",
                f"{s.median_price:.0f}", s.min_price, s.max_price,
                f"{s.avg_price_per_sqft:.0f}", f"{s.avg_area:.0f}"
            ])

Best Practices for Price Comparison

1. Compare like with like. Always filter by the same property type and bedroom count across areas. Comparing studio averages in JVC with villa averages in Palm Jumeirah is meaningless.

2. Use enough data points. Fetch at least 2-3 pages of listings per area. Averages based on 5 listings are not reliable.

3. Watch for outliers. A single AED 50M penthouse will skew the average for an entire area. Consider using median instead of mean, or trim the top and bottom 10% of prices.

4. Account for property age and quality. Price per square foot varies significantly between new and older buildings in the same area. The API does not always include building age, so keep this limitation in mind.

5. Update regularly. Property prices shift. Run your comparison monthly for reliable trend analysis.

With this tool in hand, you can make data-driven decisions about where to invest, rent, or build your next real estate application.