JLT Property Transaction Data: Sales & Rental History (Jumeirah Lake Towers)

Jumeirah Lake Towers (JLT) is one of Dubai’s most-traded apartment communities — a dense cluster of towers around four artificial lakes, popular with both end-users and buy-to-let investors. That activity makes JLT a perfect candidate for transaction-data analysis: enough volume to produce reliable medians, and a wide enough quality range to make price-per-square-foot trends meaningful.

This post shows how to pull registered JLT property transaction data — actual agreed prices, not asking prices — through the BayutAPI transactions endpoint, and how to turn it into the metrics analysts and investors care about. It is a community-level deep dive built on the approach in our Dubai real estate transaction data pillar.

JLT rental transaction data (last 12 months)

The figures below are computed from registered rental (Ejari) contracts in Jumeirah Lake Towers over the last 12 months — the same registered records Bayut surfaces, delivered as JSON. They are real signed rents, not advertised asking prices. We analysed 3,081 contracts for this snapshot.

• Median annual rent: AED 110,000/year (AED 9,167/month)
• Middle 50% (25th–75th percentile): AED 70,000–145,000/year
• Median rent per sqft: AED 120.2/sqft/year — this is annual rent per square foot, not a sale price
• Median unit size: 978 sqft
• Year-over-year change: +2.8%

A clear way to read rent per sqft: at AED 120.2/sqft/year, a 978 sqft unit pencils out close to the AED 110,000/year median. The middle-50% band of AED 70,000–145,000 reflects JLT’s spread — older, lake-facing, and newer towers price differently for the same bedroom count.

JLT rent by bedroom

Bedroom count is the strongest driver of rent within a single community. These are median annual rents from the same 12-month window:

Bedrooms	Median annual rent	Approx. monthly
Studio	AED 62,000/year	AED 5,167/month
1 bed	AED 110,000/year	AED 9,167/month
2 bed	AED 130,000/year	AED 10,833/month
3 bed	AED 163,500/year	AED 13,625/month

JLT is dominated by studios and one- and two-bed apartments, which is why the overall median (AED 110,000/year) sits right on the 1-bed figure. Apartments are effectively the whole market here — the registered median for apartments matches the overall AED 110,000/year. For deeper context on how these rents fit the wider city, see the Dubai rental market report 2026.

The API also returns for-sale transactions for JLT (set purpose=for-sale), with registered sale prices and sale price per sqft. Those are separate records from the rental medians above — do not mix annual rent/sqft with sale price/sqft. The rest of this guide shows how to pull either, so you can compute the current sale figures yourself rather than rely on a static estimate.

Step 1: Get the JLT Location ID

The transactions endpoint filters by area using a location_ids value. Look it up once with the autocomplete endpoint:

curl --request GET \
  --url 'https://uae-real-estate3.p.rapidapi.com/autocomplete?query=jumeirah%20lake%20towers' \
  --header 'x-rapidapi-host: uae-real-estate3.p.rapidapi.com' \
  --header 'x-rapidapi-key: YOUR_API_KEY'

The response returns location suggestions with their external IDs. Grab the ID for Jumeirah Lake Towers and reuse it — it does not change.

Step 2: Pull JLT Transactions

With the location ID in hand, request recent transactions for apartments in JLT. Set purpose to for-rent for registered rents (the data behind the medians above) or for-sale for registered sale prices:

import requests

URL = "https://uae-real-estate3.p.rapidapi.com/transactions"
HEADERS = {
    "x-rapidapi-host": "uae-real-estate3.p.rapidapi.com",
    "x-rapidapi-key": "YOUR_API_KEY",
}
JLT_ID = "8143"  # example value from autocomplete

def fetch_transactions(purpose: str, max_pages: int = 10, **extra) -> list[dict]:
    """Collect JLT apartment transactions across multiple pages."""
    out, page = [], 1
    while page <= max_pages:
        resp = requests.get(URL, headers=HEADERS, params={
            "purpose": purpose,
            "location_ids": JLT_ID,
            "category_ids": "apartments",
            "time_period": "12m",
            "sort_by": "date_desc",
            "page": str(page),
            **extra,  # e.g. beds="2", price_max="145000"
        })
        resp.raise_for_status()
        hits = resp.json().get("data", {}).get("hits", [])
        if not hits:
            break
        out.extend(hits)
        page += 1
    return out

rents = fetch_transactions("for-rent")
print(f"Collected {len(rents)} JLT rental transactions")

Step 3: Compute the Rent Distribution

The median and percentile spread are the headline metrics for a rental community like JLT, because they normalize across unit quality. This reproduces the AED 110,000/year median and the AED 70,000–145,000 middle-50% band:

from statistics import median

def rent_summary(transactions: list[dict]) -> dict:
    rents = sorted(
        tx["price"] for tx in transactions
        if tx.get("price")
    )
    rpsf = sorted(
        tx["price"] / tx["area"]
        for tx in transactions
        if tx.get("price") and tx.get("area")
    )
    if not rents:
        return {"count": 0}
    return {
        "count": len(rents),
        "median_annual_rent": round(median(rents)),
        "p25": round(rents[len(rents) // 4]),
        "p75": round(rents[3 * len(rents) // 4]),
        "median_rent_per_sqft_year": round(median(rpsf), 1),
    }

print(rent_summary(rents))
# e.g. {'count': 3081, 'median_annual_rent': 110000, 'p25': 70000,
#       'p75': 145000, 'median_rent_per_sqft_year': 120.2}

median_rent_per_sqft_year is annual rent divided by area — AED 120.2/sqft/year for JLT — not a sale price per sqft. The gap between the 25th and 75th percentile tells you how much spread exists between budget and premium towers in JLT: a tight band means standardized pricing, a wide band means tower quality and lake views matter a lot.

Step 4: Break Rent Down by Bedroom

Bedroom count drives rent more than anything else within a single community. Loop over the beds filter to rebuild the per-bedroom table above:

Add a beds value to the params in fetch_transactions (pass it through as an extra request param), then take the median of each slice:

def rent_by_bed(beds: str) -> int:
    txns = fetch_transactions("for-rent", beds=beds)
    prices = sorted(tx["price"] for tx in txns if tx.get("price"))
    return round(median(prices)) if prices else 0

for label, beds in [("studio", "0"), ("1-bed", "1"),
                    ("2-bed", "2"), ("3-bed", "3")]:
    print(label, rent_by_bed(beds))
# studio 62000 / 1-bed 110000 / 2-bed 130000 / 3-bed 163500

Pass beds="0" for studios and comma-separate values for multiple bedroom counts. Because every figure comes from registered transactions rather than advertised listings, the rents reflect what owners and tenants actually agreed — a more honest figure than one built from asking prices.

Step 5: Estimate Gross Rental Yield

To estimate gross yield, pull for-sale transactions the same way and compare the registered sale-price median against the registered rent median. Both sides come from real transactions, so the result reflects agreed values rather than asking prices:

sales = fetch_transactions("for-sale")

def gross_yield(sales: list[dict], rents: list[dict]) -> float:
    sale_prices = sorted(tx["price"] for tx in sales if tx.get("price"))
    annual_rents = sorted(tx["price"] for tx in rents if tx.get("price"))
    if not sale_prices or not annual_rents:
        return 0.0
    return round(median(annual_rents) / median(sale_prices) * 100, 2)

print(f"JLT gross rental yield: {gross_yield(sales, rents)}%")

Compute the sale-side median yourself from live data rather than plugging in a static estimate. For the full methodology, see Analyzing UAE Rental Yields and the rental yield definition.

Step 6: Narrow by Price or Size Segment

To isolate a specific slice — say only larger units, or rents above the median — bound results with price_min / price_max and area_min / area_max:

params = {
    "purpose": "for-rent",
    "location_ids": JLT_ID,
    "category_ids": "apartments",
    "area_min": "900",       # only units near or above the 978 sqft median
    "price_max": "145000",   # cap at the 75th-percentile rent
    "time_period": "12m",
    "page": "1",
}

This is exactly how you build comparables for a valuation tool — filter to the segment that matches a subject property, then take the median of the registered transactions that come back.

From One Community to a Whole Portfolio

The exact code above works for any Dubai community — swap the location_ids value and you have transaction data for Downtown Dubai, JVC, Business Bay, Dubai Marina, or anywhere else. That is how you build a market research dashboard or an investment screener that ranks communities by yield and price trend.

JLT is a strong starting point precisely because its volume produces stable numbers. Once your pipeline works here, scaling it across the city is a loop over location IDs.

Frequently Asked Questions

What is the average rent in JLT? The median annual rent in Jumeirah Lake Towers over the last 12 months is AED 110,000/year (about AED 9,167/month), computed from 3,081 registered rental contracts. The middle 50% of contracts fall between AED 70,000 and AED 145,000/year, and rents are up 2.8% year over year.

How much is rent per square foot in JLT? Median rent per square foot is AED 120.2/sqft per year. Note this is annual rent per sqft, not a sale price per sqft — a 978 sqft unit at that rate works out close to the AED 110,000/year median.

Where does JLT transaction data come from? Registered sale and rental transactions originate with the Dubai Land Department. Bayut aggregates and surfaces those DLD-registered records, and BayutAPI serves them as query-ready JSON through the transactions endpoint.

Can I get rental (Ejari) transaction data for JLT? Yes — set purpose=for-rent. This returns registered tenancy values, which power the medians above and which you can compare against for-sale prices to estimate gross yield.

How do I do this for another area? Look up the new area’s ID with the autocomplete endpoint and pass it as location_ids. Everything else stays the same.

Next steps

JLT shows how a single community’s registered transactions become real, defensible market metrics. Point the same pipeline at the rest of Dubai and you have a city-wide view.

• Read the Dubai real estate transaction data pillar for the full data model
• See the city-wide picture in the Dubai rental market report 2026
• Browse the JLT location profile and JLT apartments
• See every parameter in the transactions endpoint reference
• Look up the transactions glossary term for what counts as a registered record