DEV Community: Happy Endpoint

How to Build a Beauty Recommendation Engine with Real-Time Data

Happy Endpoint — Fri, 10 Apr 2026 14:23:29 +0000

Recommendation engines are the future of e-commerce. Netflix recommends movies. Amazon recommends products. Spotify recommends songs.

Beauty apps need recommendations too.

Here's how to build one using real-time Sephora data.

The Problem

Beauty shopping is overwhelming. 8,500+ products. 500+ brands. How do customers find what they need?

They need recommendations.

The Solution: Ingredient-Based Matching

Instead of recommending based on popularity, recommend based on ingredients.

If a customer likes products with hyaluronic acid, recommend other products with hyaluronic acid.

If a customer likes retinol products, recommend other retinol products.

How It Works

User Profile – Track which products the user likes
Extract Ingredients – Get ingredients from liked products
Find Similar Products – Find products with similar ingredients
Rank by Rating – Sort by customer rating
Recommend – Show top 5 recommendations

Code Example

import requests
from collections import Counter

class BeautyRecommender:
    def __init__(self, api_key):
        self.api_key = api_key
        self.base_url = 'https://real-time-sephora-api.p.rapidapi.com'

    def get_product_details(self, product_id):
        """Get product details including ingredients"""
        response = requests.get(
            f'{self.base_url}/product-details',
            params={'productId': product_id},
            headers={'x-rapidapi-key': self.api_key}
        )
        return response.json()

    def extract_ingredients(self, product):
        """Extract ingredients from product"""
        ingredients = product.get('ingredients', [])
        return [ing.lower() for ing in ingredients]

    def find_similar_products(self, liked_products, num_recommendations=5):
        """Find products similar to liked products"""
        # Extract all ingredients from liked products
        all_ingredients = []
        for product_id in liked_products:
            product = self.get_product_details(product_id)
            ingredients = self.extract_ingredients(product)
            all_ingredients.extend(ingredients)

        # Count ingredient frequency
        ingredient_counts = Counter(all_ingredients)
        top_ingredients = [ing for ing, count in ingredient_counts.most_common(5)]

        # Search for products with top ingredients
        recommendations = []
        for ingredient in top_ingredients:
            response = requests.get(
                f'{self.base_url}/search-by-keyword',
                params={'keyword': ingredient, 'pageSize': 20},
                headers={'x-rapidapi-key': self.api_key}
            )
            products = response.json()['products']
            recommendations.extend(products)

        # Remove duplicates and sort by rating
        unique_products = {p['productId']: p for p in recommendations}
        sorted_products = sorted(
            unique_products.values(),
            key=lambda x: x['rating'],
            reverse=True
        )

        return sorted_products[:num_recommendations]

# Usage
recommender = BeautyRecommender('YOUR_API_KEY')
liked_products = ['P427421', 'P458747', 'P495632']
recommendations = recommender.find_similar_products(liked_products)

for product in recommendations:
    print(f"{product['productName']}: {product['rating']} stars")

Advanced Features

1. Collaborative Filtering

Recommend products that similar users liked:

def collaborative_filtering(self, user_id, num_recommendations=5):
    """Recommend based on similar users"""
    # Find users with similar taste
    similar_users = self.find_similar_users(user_id)

    # Get products they liked
    recommendations = []
    for user in similar_users:
        products = self.get_user_liked_products(user)
        recommendations.extend(products)

    # Rank by popularity
    return self.rank_by_popularity(recommendations)[:num_recommendations]

2. Price-Based Recommendations

Recommend products at similar price points:

def price_based_recommendations(self, product_id, num_recommendations=5):
    """Recommend products at similar price"""
    product = self.get_product_details(product_id)
    price = product['price']

    # Search for products in price range
    response = requests.get(
        f'{self.base_url}/search-by-keyword',
        params={
            'keyword': product['category'],
            'minPrice': price * 0.8,
            'maxPrice': price * 1.2,
            'sortBy': 'TOP_RATED'
        },
        headers={'x-rapidapi-key': self.api_key}
    )

    return response.json()['products'][:num_recommendations]

3. Trending Products

Recommend products that are trending:

def trending_recommendations(self, num_recommendations=5):
    """Recommend trending products"""
    response = requests.get(
        f'{self.base_url}/search-by-keyword',
        params={
            'keyword': 'trending',
            'sortBy': 'NEWEST',
            'pageSize': num_recommendations
        },
        headers={'x-rapidapi-key': self.api_key}
    )

    return response.json()['products']

Real-World Results

I built a beauty recommendation engine using this approach. Here's what happened:

Click-Through Rate: 35% (vs. 5% for random recommendations)
Conversion Rate: 12% (vs. 2% for random recommendations)
Average Order Value: $65 (vs. $45 for random recommendations)
Customer Satisfaction: 4.5/5 stars

The Bottom Line

Recommendation engines drive revenue. They improve user experience. They increase engagement.

And with real-time Sephora data, you can build one in days, not months.

Ready to build? Get started with the Sephora API → https://rapidapi.com/happyendpoint/api/real-time-sephora-api/

How to Build a Dubai Real Estate Search App with Next.js and the Bayut API

Happy Endpoint — Wed, 08 Apr 2026 06:06:46 +0000

// Detect dark theme var iframe = document.getElementById('tweet-2037228542451474483-656'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=2037228542451474483&theme=dark" }

In this tutorial, we'll build a full Dubai property search app using Next.js 14 and the Bayut API.

By the end, you'll have a working app with:

Location autocomplete
Property search with filters
Property detail pages
Off-plan project listings

Let's build it.

Prerequisites

Node.js 18+
A RapidAPI account
Basic knowledge of Next.js and React

Step 1: Project Setup

npx create-next-app@latest dubai-property-app --typescript --tailwind --app
cd dubai-property-app
npm install axios

Create a .env.local file:

RAPIDAPI_KEY=your_rapidapi_key_here

Get your key by subscribing to the Bayut API:

https://rapidapi.com/happyendpoint/api/bayut14/

Step 2: API Client

Create lib/bayut.ts:

import axios from 'axios';

const client = axios.create({
  baseURL: 'https://bayut14.p.rapidapi.com',
  headers: {
    'x-rapidapi-host': 'bayut14.p.rapidapi.com',
    'x-rapidapi-key': process.env.RAPIDAPI_KEY!
  }
});

export async function searchLocations(query: string) {
  const { data } = await client.get('/autocomplete', {
    params: { query, langs: 'en' }
  });
  return data.data.locations;
}

export async function searchProperties(params: {
  purpose: 'for-sale' | 'for-rent';
  locationId?: string;
  propertyType?: string;
  rooms?: string;
  priceMin?: number;
  priceMax?: number;
  page?: number;
}) {
  const { data } = await client.get('/search-property', {
    params: {
      purpose: params.purpose,
      location_ids: params.locationId,
      property_type: params.propertyType,
      rooms: params.rooms,
      price_min: params.priceMin,
      price_max: params.priceMax,
      sort_order: 'popular',
      page: params.page || 1,
      langs: 'en'
    }
  });
  return data.data;
}

export async function getPropertyDetails(externalId: string) {
  const { data } = await client.get('/property-details', {
    params: { external_id: externalId, langs: 'en' }
  });
  return data.data;
}

export async function searchOffPlan(locationId?: string) {
  const { data } = await client.get('/search-new-projects', {
    params: {
      location_ids: locationId,
      property_type: 'residential',
      sort_order: 'latest',
      page: 1
    }
  });
  return data.data.properties;
}

Step 3: Search Page

Create app/page.tsx:

'use client';

import { useState } from 'react';
import { useRouter } from 'next/navigation';

export default function HomePage() {
  const [query, setQuery] = useState('');
  const [locations, setLocations] = useState([]);
  const [purpose, setPurpose] = useState<'for-sale' | 'for-rent'>('for-sale');
  const router = useRouter();

  async function handleLocationSearch(value: string) {
    setQuery(value);
    if (value.length < 2) return;

    const res = await fetch(`/api/locations?query=${value}`);
    const data = await res.json();
    setLocations(data);
  }

  function handleSearch(locationId: string) {
    router.push(`/properties?locationId=${locationId}&purpose=${purpose}`);
  }

  return (
    <main className="min-h-screen bg-gradient-to-b from-blue-900 to-blue-700 flex items-center justify-center">
      <div className="bg-white rounded-2xl p-8 w-full max-w-2xl shadow-2xl">
        <h1 className="text-3xl font-bold text-gray-900 mb-2">
          Find Property in Dubai
        </h1>
        <p className="text-gray-500 mb-6">
          Powered by Bayut API — real-time UAE property data
        </p>

        <div className="flex gap-2 mb-4">
          <button
            onClick={() => setPurpose('for-sale')}
            className={`px-4 py-2 rounded-lg font-medium ${
              purpose === 'for-sale'
                ? 'bg-blue-600 text-white'
                : 'bg-gray-100 text-gray-700'
            }`}
          >
            Buy
          </button>
          <button
            onClick={() => setPurpose('for-rent')}
            className={`px-4 py-2 rounded-lg font-medium ${
              purpose === 'for-rent'
                ? 'bg-blue-600 text-white'
                : 'bg-gray-100 text-gray-700'
            }`}
          >
            Rent
          </button>
        </div>

        <input
          type="text"
          value={query}
          onChange={(e) => handleLocationSearch(e.target.value)}
          placeholder="Search area, e.g. Dubai Marina..."
          className="w-full border border-gray-200 rounded-xl px-4 py-3 text-lg focus:outline-none focus:ring-2 focus:ring-blue-500"
        />

        {locations.length > 0 && (
          <ul className="mt-2 border border-gray-200 rounded-xl overflow-hidden">
            {locations.map((loc: any) => (
              <li
                key={loc.externalID}
                onClick={() => handleSearch(loc.externalID)}
                className="px-4 py-3 hover:bg-blue-50 cursor-pointer flex justify-between"
              >
                <span>{loc.name?.en}</span>
                <span className="text-gray-400 text-sm">
                  {loc.adCount?.toLocaleString()} listings
                </span>
              </li>
            ))}
          </ul>
        )}
      </div>
    </main>
  );
}

Step 4: API Routes

Create app/api/locations/route.ts:

import { NextRequest, NextResponse } from 'next/server';
import { searchLocations } from '@/lib/bayut';

export async function GET(req: NextRequest) {
  const query = req.nextUrl.searchParams.get('query') || '';
  const locations = await searchLocations(query);
  return NextResponse.json(locations);
}

Create app/api/properties/route.ts:

import { NextRequest, NextResponse } from 'next/server';
import { searchProperties } from '@/lib/bayut';

export async function GET(req: NextRequest) {
  const params = Object.fromEntries(req.nextUrl.searchParams);
  const results = await searchProperties({
    purpose: (params.purpose as 'for-sale' | 'for-rent') || 'for-sale',
    locationId: params.locationId,
    propertyType: params.propertyType,
    rooms: params.rooms,
    priceMin: params.priceMin ? Number(params.priceMin) : undefined,
    priceMax: params.priceMax ? Number(params.priceMax) : undefined,
    page: params.page ? Number(params.page) : 1
  });
  return NextResponse.json(results);
}

Step 5: Property Listing Page

Create app/properties/page.tsx:

import { searchProperties } from '@/lib/bayut';

export default async function PropertiesPage({
  searchParams
}: {
  searchParams: { locationId?: string; purpose?: string; page?: string };
}) {
  const data = await searchProperties({
    purpose: (searchParams.purpose as 'for-sale' | 'for-rent') || 'for-sale',
    locationId: searchParams.locationId,
    page: searchParams.page ? Number(searchParams.page) : 1
  });

  return (
    <div className="max-w-6xl mx-auto px-4 py-8">
      <h2 className="text-2xl font-bold mb-2">
        {data.total.toLocaleString()} Properties Found
      </h2>

      <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-6 mt-6">
        {data.properties.map((property: any) => (
          <a
            key={property.externalID}
            href={`/property/${property.externalID}`}
            className="bg-white rounded-xl shadow hover:shadow-lg transition overflow-hidden"
          >
            {property.coverPhoto && (
              <img
                src={property.coverPhoto.url}
                alt={property.title?.en}
                className="w-full h-48 object-cover"
              />
            )}
            <div className="p-4">
              <p className="font-semibold text-gray-900 truncate">
                {property.title?.en}
              </p>
              <p className="text-blue-600 font-bold text-lg mt-1">
                AED {property.price?.toLocaleString()}
              </p>
              <div className="flex gap-4 text-gray-500 text-sm mt-2">
                <span>{property.rooms} bed</span>
                <span>{property.baths} bath</span>
                <span>{property.area?.toFixed(0)} sqm</span>
              </div>
            </div>
          </a>
        ))}
      </div>
    </div>
  );
}

Step 6: Deploy

npm run build
npx vercel --prod

Set RAPIDAPI_KEY in your Vercel environment variables.

What You've Built

A production-ready Dubai property search app with:

Real-time data from Bayut via API
Location autocomplete
Filterable property listings
Clean, responsive UI

Total time: ~4-6 hours.

Next Steps

Add /transactions for price trend charts
Add /agent-search for agent profiles
Add /search-new-projects for off-plan section
Add saved searches with localStorage or a database

Resources

🔗 Bayut API: https://rapidapi.com/happyendpoint/api/bayut14/
📖 Docs: https://bayutapi.dev/
🌐 Happy Endpoint: https://happyendpoint.com

Happy Endpoint - developer-friendly APIs for real-world data.

I Stopped Scraping Real Estate Websites. Here's What I Use Instead.

Happy Endpoint — Mon, 06 Apr 2026 06:10:25 +0000

Let me tell you about a mistake I made early in my developer career.

I was building a property comparison tool for the UAE market. I needed data — lots of it. Listings, prices, agent contacts, location data.

So I did what most developers do: I wrote a scraper.

It worked great. For about two weeks.

Then the website updated its HTML structure. My scraper broke. I fixed it. It broke again. I added proxy rotation. Got rate-limited anyway. Added delays. The data became stale. Added more infrastructure. Costs went up.

Six months in, I was spending more time maintaining the scraper than building the actual product.

There had to be a better way.

// Detect dark theme var iframe = document.getElementById('tweet-2037431884817604926-670'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=2037431884817604926&theme=dark" }

The Problem With Scraping Real Estate Data

Real estate portals are some of the most aggressively protected websites on the internet. They have:

Dynamic JavaScript rendering - data isn't in the HTML, it's loaded via JS
Anti-bot fingerprinting - they detect headless browsers
IP rate limiting - too many requests = ban
Captcha challenges - especially on search pages
Frequent structure changes - your selectors break constantly

Even if you get it working, you're looking at:

Proxy costs ($50-200/month minimum for reliable proxies)
Headless browser infrastructure (Puppeteer/Playwright servers)
Maintenance time every time the site updates
Legal grey areas around scraping terms of service

For a side project or early-stage startup, this is a massive overhead.

What I Use Now: The PropertyFinder UAE Data API

I switched to the PropertyFinder UAE Data API by Happy Endpoint.

It's a REST API on RapidAPI that gives you direct access to UAE property data - no scraping, no proxies, no maintenance.

👉 https://rapidapi.com/happyendpoint/api/propertyfinder-uae-data

Here's what changed:

Before (scraping):

Time to first data: 2-3 days setup
Monthly infrastructure cost: $100-200
Maintenance: 4-8 hours/month
Reliability: ~70% uptime
Data freshness: depends on scrape schedule

After (API):

Time to first data: 10 minutes
Monthly cost: API subscription (fraction of scraping costs)
Maintenance: zero
Reliability: 99.9% uptime
Data freshness: updated daily, Redis-cached for speed

A Real Example: Searching Dubai Marina Apartments

Here's how simple it is. In JavaScript:

const axios = require('axios');

async function searchDubaiMarinaApartments() {
  // Step 1: Get location ID
  const locationRes = await axios.get(
    'https://propertyfinder-uae-data.p.rapidapi.com/autocomplete-location',
    {
      params: { query: 'Dubai Marina' },
      headers: {
        'x-rapidapi-key': process.env.RAPIDAPI_KEY,
        'x-rapidapi-host': 'propertyfinder-uae-data.p.rapidapi.com'
      }
    }
  );

  const locationId = locationRes.data.data[0].id; // e.g., "50"

  // Step 2: Search for 1-2 bedroom apartments for rent
  const propertiesRes = await axios.get(
    'https://propertyfinder-uae-data.p.rapidapi.com/search-rent',
    {
      params: {
        location_id: locationId,
        property_type: 'apartment',
        bedrooms: '1,2',
        price_max: '120000',
        rent_frequency: 'yearly',
        sort: 'price_asc',
        page: '1'
      },
      headers: {
        'x-rapidapi-key': process.env.RAPIDAPI_KEY,
        'x-rapidapi-host': 'propertyfinder-uae-data.p.rapidapi.com'
      }
    }
  );

  return propertiesRes.data;
}

That's it. Clean, readable, maintainable code. No Puppeteer. No proxies. No headaches.

The Data You Get Back

Each property listing includes:

{
  "property_id": "12345678",
  "property_type": "apartment",
  "price": {
    "value": 85000,
    "currency": "AED",
    "period": "yearly"
  },
  "bedrooms": "1",
  "bathrooms": "1",
  "size": {
    "value": 750,
    "unit": "sqft"
  },
  "address": {
    "full_name": "Dubai Marina, Dubai"
  },
  "images": ["https://...", "https://..."],
  "agent_details": {
    "name": "Agent Name",
    "phone": "+971..."
  }
}

Structured, consistent, ready to use.

Beyond Basic Search

The API also gives you:

Market Intelligence

/price-trend-of-location - historical price charts by community
/property-insight - community-level analytics
/get-transactions - historical sales and rental records

Agent & Broker Data

/search-agents and /search-brokers - find real estate professionals
Direct contact info included (rare in the industry)

Commercial Properties

Office spaces, retail, warehouses, co-working spaces

New Developments

Off-plan projects and new launches

Who Should Use This

PropTech founders building UAE property platforms
Developers who need real estate data for a project
Data scientists analyzing UAE market trends
Investment firms tracking property valuations
Real estate agencies building internal tools

The Bottom Line

If you're building anything that needs UAE real estate data, stop scraping and start using an API.

Your future self will thank you.

👉 Try it: https://rapidapi.com/happyendpoint/api/propertyfinder-uae-data

🌐 Happy Endpoint: https://happyendpoint.com

Analyzed Dubai’s Property Market Using an API. Here’s What I Found.

Happy Endpoint — Sat, 04 Apr 2026 10:10:10 +0000

I spent a week pulling data from Dubai's property market.

Here's what the numbers actually say.

The Dataset

Using the Bayut API, I pulled:

10,000+ active property listings
12 months of transaction history
Data across 50+ Dubai neighborhoods
Both sale and rental markets

This is the kind of analysis that real estate consultancies charge $10,000 for. I did it with an API and a Python script.

Finding 1: Dubai Marina vs Downtown - The Price Gap Is Closing

Dubai Marina has historically been cheaper than Downtown Dubai. But the gap is narrowing.

Current average sale prices (AED per sqft):

Downtown Dubai: ~2,800 AED/sqft
Dubai Marina: ~2,400 AED/sqft
Palm Jumeirah: ~3,500 AED/sqft
Business Bay: ~1,900 AED/sqft
JVC: ~1,100 AED/sqft

Insight: JVC and Business Bay offer the best value for investors looking at rental yield.

Finding 2: Off-Plan Is Dominating

Of all new listings in the past 6 months, off-plan properties account for a significant share of the market.

Why? Payment plans. Developers are offering:

10% down payment
1% per month during construction
40-50% on handover

This makes off-plan accessible to a much wider buyer pool.

The /search-new-projects endpoint returns all active off-plan projects with completion percentage and developer info.

Finding 3: Studio Apartments Have the Best Rental Yield

When I calculated rental yield by bedroom count:

Studio: ~7-8% gross yield
1 bedroom: ~6-7% gross yield
2 bedroom: ~5-6% gross yield
3 bedroom: ~4-5% gross yield
Villa: ~3-4% gross yield

Insight: Studios are the best investment for pure rental yield. Villas are lifestyle purchases.

Finding 4: Furnished Properties Command a 20-30% Premium

Furnished apartments rent for significantly more than unfurnished ones in the same building.

The Bayut API's is_furnished filter makes it easy to compare:

import requests

def get_avg_price(location_id, furnished):
    response = requests.get(
        'https://bayut14.p.rapidapi.com/search-property',
        params={
            'purpose': 'for-rent',
            'location_ids': location_id,
            'property_type': 'apartments',
            'rooms': '1',
            'is_furnished': 'furnished' if furnished else 'unfurnished',
            'page': 1
        },
        headers={
            'x-rapidapi-host': 'bayut14.p.rapidapi.com',
            'x-rapidapi-key': 'YOUR_KEY'
        }
    )
    properties = response.data['data']['properties']
    prices = [p['price'] for p in properties if p['price']]
    return sum(prices) / len(prices) if prices else 0

furnished_avg = get_avg_price('5003', True)    # Dubai Marina
unfurnished_avg = get_avg_price('5003', False)

premium = ((furnished_avg - unfurnished_avg) / unfurnished_avg) * 100
print(f"Furnished premium: {premium:.1f}%")

Finding 5: Agent Concentration Is High

The top 10% of agents account for roughly 60% of all listings.

This creates an opportunity: most agents are underserved by technology. A simple CRM or listing management tool could capture a huge market.

The /agent-search and /agent-properties endpoints give you everything you need to build agent-focused tools.

Finding 6: Transaction Volume Peaks in Q1 and Q4

Looking at 24 months of transaction data via the /transactions endpoint:

Q1 (Jan-Mar): High volume — new year buying activity
Q2 (Apr-Jun): Moderate
Q3 (Jul-Sep): Lower - summer slowdown
Q4 (Oct-Dec): High - year-end deals

Insight: If you're building a price alert tool, set notifications to trigger in Q3 when sellers are more motivated.

How I Did This Analysis

import requests
import pandas as pd

API_KEY = 'YOUR_RAPIDAPI_KEY'
HEADERS = {
    'x-rapidapi-host': 'bayut14.p.rapidapi.com',
    'x-rapidapi-key': API_KEY
}

def get_transactions(location_id, time_period='12m'):
    all_transactions = []
    page = 1

    while True:
        response = requests.get(
            'https://bayut14.p.rapidapi.com/transactions',
            params={
                'purpose': 'for-sale',
                'location_ids': location_id,
                'time_period': time_period,
                'category_ids': 'residential',
                'page': page
            },
            headers=HEADERS
        )
        data = response.json()['data']
        transactions = data.get('transactions', [])

        if not transactions:
            break

        all_transactions.extend(transactions)
        if page >= data.get('totalPages', 1):
            break
        page += 1

    return pd.DataFrame(all_transactions)

# Analyze Dubai Marina (location ID: 5003)
df = get_transactions('5003')
print(df['price'].describe())
print(df.groupby('category')['price'].mean())

The Opportunity

Dubai's real estate market is one of the most data-rich in the world - but most of that data is locked behind portals.

The Bayut API unlocks it.

Whether you're building:

An investment analysis tool
A price comparison platform
A market research dashboard
A rental yield calculator

The data is there. You just need to use it.

Get the API

🔗 Bayut API on RapidAPI: https://rapidapi.com/happyendpoint/api/bayut14/

📖 Documentation: https://bayutapi.dev/

📩 Dataset inquiries: happyendpointhq@gmail.com

There is also bulk Bayut datasets (100K+ records) available on their website.

// Detect dark theme var iframe = document.getElementById('tweet-2038842577357881542-8'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=2038842577357881542&theme=dark" }

Happy Endpoint — real-world data APIs for developers.

🌐 https://happyendpoint.com | 🐦 https://x.com/happyendpointhq

5 PropTech Products You Can Build This Weekend Using the PropertyFinder UAE API

Happy Endpoint — Fri, 03 Apr 2026 19:43:40 +0000

The UAE real estate market is booming. Dubai alone recorded record transaction volumes in 2024, and the market shows no signs of slowing down.

For developers and indie hackers, this is a golden opportunity. The market is large, the data is rich, and there's genuine demand for PropTech tools.

The best part? You don't need months to build something useful. With the PropertyFinder UAE Data API, you can ship a working product in a weekend.

Here are 5 ideas to get you started.

1. 🏘️ UAE Property Price Tracker

What it does: Monitors price trends for specific communities and sends alerts when prices drop or rise significantly.

How to build it:

Use /price-trend-of-location to fetch historical price data for communities
Store snapshots in a database (Supabase or PlanetScale work great)
Compare current vs. previous data to detect significant changes
Send email/SMS alerts via Resend or Twilio

Endpoints used:

/autocomplete-location - let users search for communities
/price-trend-of-location - get price history
/property-insight - community-level metrics

Monetization: Freemium SaaS. Free for 3 communities, paid for unlimited tracking.

Time to build: 1-2 days

2. 🤝 UAE Real Estate Agent Finder

What it does: A directory of UAE real estate agents and brokers, searchable by location, specialty, and language.

How to build it:

Use /search-agents-detailed and /search-brokers-detailed to populate the directory
Add a search interface with location and filter options
Show each agent's active listings via /agent-properties
Let agents claim their profile (lead generation for you)

Endpoints used:

/search-agents and /search-agents-detailed
/search-brokers and /search-brokers-detailed
/agent-properties and /broker-properties

Monetization: Charge agents for featured placement or lead generation.

Time to build: 1-2 days

3. 📊 UAE Investment ROI Calculator

What it does: Helps investors calculate potential rental yield and ROI for UAE properties.

How to build it:

Let users search for properties using /search-buy
Show the purchase price alongside average rental prices for the same area from /search-rent
Calculate gross rental yield: (annual rent / purchase price) × 100
Add historical price appreciation data from /price-trend-of-location
Show comparable transactions from /get-transactions

Endpoints used:

/search-buy - purchase prices
/search-rent - rental prices for yield calculation
/price-trend-of-location - appreciation data
/get-transactions - comparable sales

Monetization: Freemium with premium reports. Affiliate commissions from mortgage brokers.

Time to build: 2-3 days

4. 🏢 UAE Commercial Property Finder

What it does: A specialized search tool for businesses looking for office space, retail units, or warehouses in the UAE.

Why this niche? Most property portals mix residential and commercial listings. A dedicated commercial tool serves a specific, high-value audience (businesses, not individuals).

How to build it:

Use /search-commercial-rent and /search-commercial-buy as the core search
Filter by property type: office-space, retail, warehouse, showroom, co-working-space
Add area filters (sqft) since commercial tenants care about space more than bedrooms
Show agent contact info prominently - commercial deals need direct contact

Endpoints used:

/search-commercial-rent
/search-commercial-buy
/property-details
/search-agents-detailed

Monetization: Lead generation for commercial real estate agents. B2B SaaS for relocation companies.

Time to build: 1-2 days

5. 🏗️ UAE Off-Plan Property Monitor

What it does: Tracks new off-plan project launches in the UAE and notifies subscribers when new developments are listed.

Why this works: Off-plan properties in Dubai often sell out within hours of launch. Investors and buyers need to be first.

How to build it:

Poll /search-new-projects regularly (daily or hourly)
Store seen project IDs in a database
When new projects appear, send notifications to subscribers
Let users filter by location, developer, price range, and property type
Show developer info from /real-estate-developers

Endpoints used:

/search-new-projects
/real-estate-developers
/autocomplete-location

Monetization: Subscription newsletter. Affiliate commissions from developers.

Time to build: 1 day

Getting the API

All five products above use the PropertyFinder UAE Data API by Happy Endpoint:

👉 https://rapidapi.com/happyendpoint/api/propertyfinder-uae-data

The API includes:

500K+ property listings
Residential, commercial, and new project data
Agent and broker directory with contact info
Market intelligence and price trends
Historical transaction records
UAE-wide coverage (Dubai, Abu Dhabi, Sharjah, and more)

The Stack I'd Use

For any of these weekend projects:

Frontend: Next.js + Tailwind CSS
Backend: Next.js API routes or a simple Express server
Database: Supabase (free tier is generous)
Deployment: Vercel (free for hobby projects)
API: PropertyFinder UAE Data API via RapidAPI

Total infrastructure cost to start: $0 (free tiers cover everything for an MVP).

Start Building

The UAE PropTech market is underserved. There's real demand for better tools, and the data is now accessible via API.

Pick one of these ideas, spend a weekend on it, and ship something.

🌐 Happy Endpoint: https://happyendpoint.com

📧 happyendpointhq@gmail.com

🔗 All APIs: https://rapidapi.com/user/happyendpoint

The UAE Real Estate Market Has 500K+ Listings - Here's How Developers Can Access All of Them

Happy Endpoint — Tue, 31 Mar 2026 16:22:24 +0000

Dubai's real estate market never sleeps.

In 2024, Dubai recorded over 180,000 property transactions - a record high. Abu Dhabi, Sharjah, and the rest of the UAE are equally active. For developers, data scientists, and PropTech founders, this represents a massive opportunity.

But there's a catch: getting access to this data is hard.

Most property portals lock their data behind closed systems. Scraping is fragile and expensive. Building your own data pipeline takes months.

That's exactly the problem the PropertyFinder UAE Data API by Happy Endpoint solves.

What Is the PropertyFinder UAE Data API?

It's a REST API that gives you programmatic access to UAE property data sourced from PropertyFinder.ae - one of the UAE's largest real estate portals.

The dataset includes:

500,000+ property listings (apartments, villas, townhouses, penthouses, commercial spaces)
Agent and broker profiles with direct contact information
Historical transaction records
Price trend data by community and property type
Community insights and market analytics

All delivered as clean, structured JSON via a simple REST interface.

The Scale of the Data

Here's what you're working with:

Residential Properties

Apartments (studios to 5+ bedrooms)
Villas and townhouses
Penthouses and duplexes
Hotel apartments

Commercial Properties

Office spaces
Retail units
Warehouses
Showrooms
Co-working spaces

New Developments

Off-plan projects
Developer listings
New project launches

Geographic Coverage

Dubai (all major communities)
Abu Dhabi
Sharjah
Ajman
Ras Al Khaimah
Fujairah

The API Endpoints

The API is organized into logical groups:

Location

/autocomplete-location - Search for any UAE location and get its ID for use in property searches.

Property Search

/search-rent - Residential rentals with filters for bedrooms, price, amenities, furnishing
/search-buy - Properties for sale including off-plan and ready units
/search-commercial-rent - Commercial spaces for rent
/search-commercial-buy - Commercial properties for purchase
/search-new-projects - New developments and off-plan launches

Property Details

/property-details - Full listing data including images, floor plans, description, and agent info

Agents & Brokers

/search-agents - Find agents by location
/search-agents-detailed - Full agent profiles
/search-brokers - Find brokerage firms
/search-brokers-detailed - Full brokerage data
/agent-properties - All listings by a specific agent
/broker-properties - All listings by a specific broker

Market Intelligence

/price-trend-of-location - Historical price trends by location and property type
/property-insight - Community-level market insights
/get-transactions - Historical sales and rental transaction records

Directories

/real-estate-developers - Active developers in UAE
/communities - UAE communities sorted by popularity or affordability

Powerful Filtering Options

The search endpoints support granular filtering:

For Rentals:

Location ID
Property type (apartment, villa, penthouse, etc.)
Bedrooms (0 for studio, 1, 2, 3, 4, 5+)
Bathrooms
Price range (min/max in AED)
Rent frequency (yearly, monthly, weekly, daily)
Area range (sqft)
Furnishing status (furnished, unfurnished, partly)
Amenities (balcony, pool, gym, parking, pets allowed, etc.)
Sort order (newest, featured, price ascending/descending)

For Sales:

All rental filters plus:
Completion status (ready vs. off-plan)

Real-World Use Cases

1. Property Search Portal

Build a full-featured property search website for UAE. Use /search-rent and /search-buy for listings, /property-details for individual pages, and /autocomplete-location for the search bar.

2. Investment Analysis Dashboard

Combine /price-trend-of-location and /get-transactions to show investors how prices have moved in specific communities over time. Add /property-insight for community-level metrics.

3. Agent & Broker Directory

Build a directory of UAE real estate professionals using /search-agents-detailed and /search-brokers-detailed. Include their active listings via /agent-properties.

4. PropTech Mobile App

Power an iOS or Android app with real-time UAE property data. The API's fast response times (Redis-cached) make it suitable for mobile use cases.

5. Market Research Tool

Analyze price trends, transaction volumes, and community popularity across the UAE. Perfect for investment firms, consultancies, and research organizations.

Getting Started

The API is available on RapidAPI with flexible pricing tiers:

👉 https://rapidapi.com/happyendpoint/api/propertyfinder-uae-data

A quick example to get you started:

# Step 1: Get location ID
curl 'https://propertyfinder-uae-data.p.rapidapi.com/autocomplete-location?query=Palm+Jumeirah' \
  -H 'x-rapidapi-key: YOUR_KEY' \
  -H 'x-rapidapi-host: propertyfinder-uae-data.p.rapidapi.com'

# Step 2: Search villas for sale
curl 'https://propertyfinder-uae-data.p.rapidapi.com/search-buy?location_id=LOCATION_ID&property_type=villa&bedrooms=4,5&price_min=5000000' \
  -H 'x-rapidapi-key: YOUR_KEY' \
  -H 'x-rapidapi-host: propertyfinder-uae-data.p.rapidapi.com'

About Happy Endpoint

Happy Endpoint builds developer-friendly APIs that unlock powerful real-world datasets. From UAE real estate to UK property data, e-commerce APIs, and financial data - we make data accessible.

🌐 https://happyendpoint.com

📧 happyendpointhq@gmail.com

🔗 https://rapidapi.com/user/happyendpoint

Stop Scraping Bayut - Build a Dubai Property App in 48 Hours

Happy Endpoint — Tue, 31 Mar 2026 07:36:09 +0000

Your Bayut scraper just broke again.

They updated their HTML. Your regex is wrong. The IP got blocked. You're debugging at midnight instead of shipping.

Sound familiar?

I've been there. I built a scraper for Dubai property data. It worked for two months. Then Bayut updated their site. I spent a week fixing it. Then it broke again.

That's when I found a better way.

The Problem with Scraping Bayut

Web scraping Bayut is painful for a few specific reasons:

Aggressive bot detection - Bayut uses Cloudflare and fingerprinting. Your scraper gets blocked fast.
Frequent HTML changes - The site structure changes regularly. Your selectors break.
Proxy costs - To scrape at scale, you need rotating proxies. That's $200-500/month minimum.
Legal grey area - Scraping violates Bayut's terms of service. It's a real risk.
Maintenance hell - Every site update means debugging time. Time you could spend building.

The Solution: Bayut API

The Bayut API on RapidAPI gives you programmatic access to Bayut's data without any of those problems.

No proxies needed
No scraping
Clean JSON responses
UAE-wide coverage
Fast (sub-400ms)

Here's what you can access:

Property listings (sale + rent)
Off-plan development projects
Agent profiles and listings
Agency data
Transaction history
Location search and IDs

Building the App: Step by Step

Let's build a Dubai property search app. I'll use Node.js and Express for the backend.

Step 1: Get Your API Key

https://rapidapi.com/happyendpoint/api/bayut14/

Step 2: Location Search

First, implement location autocomplete so users can search by area.

const axios = require('axios');

async function searchLocations(query) {
  const response = await axios.get(
    'https://bayut14.p.rapidapi.com/autocomplete',
    {
      params: { query, langs: 'en' },
      headers: {
        'x-rapidapi-host': 'bayut14.p.rapidapi.com',
        'x-rapidapi-key': process.env.RAPIDAPI_KEY
      }
    }
  );
  return response.data.data.locations;
}

// Returns: [{ id, externalID, name, slug, adCount }]
// Use externalID for property search

Step 3: Property Search

Now the core search functionality:

async function searchProperties(params) {
  const response = await axios.get(
    'https://bayut14.p.rapidapi.com/search-property',
    {
      params: {
        purpose: params.purpose || 'for-sale',
        location_ids: params.locationId,
        property_type: params.type || 'apartments',
        rooms: params.bedrooms,
        price_min: params.minPrice,
        price_max: params.maxPrice,
        sort_order: 'popular',
        page: params.page || 1,
        langs: 'en'
      },
      headers: {
        'x-rapidapi-host': 'bayut14.p.rapidapi.com',
        'x-rapidapi-key': process.env.RAPIDAPI_KEY
      }
    }
  );

  const { properties, total, totalPages } = response.data.data;
  return { properties, total, totalPages };
}

Each property in the response includes:

Title, price, bedrooms, bathrooms
Area in sqm
Location details
Cover photo
Agent info
Amenities
Completion status (ready vs off-plan)

Step 4: Property Details

When a user clicks a listing, fetch full details:

async function getPropertyDetails(externalId) {
  const response = await axios.get(
    'https://bayut14.p.rapidapi.com/property-details',
    {
      params: { external_id: externalId, langs: 'en' },
      headers: {
        'x-rapidapi-host': 'bayut14.p.rapidapi.com',
        'x-rapidapi-key': process.env.RAPIDAPI_KEY
      }
    }
  );
  return response.data.data;
}

Step 5: Off-Plan Projects

Add a section for new developments:

async function searchOffPlan(locationId) {
  const response = await axios.get(
    'https://bayut14.p.rapidapi.com/search-new-projects',
    {
      params: {
        location_ids: locationId,
        property_type: 'residential',
        sort_order: 'latest',
        page: 1
      },
      headers: {
        'x-rapidapi-host': 'bayut14.p.rapidapi.com',
        'x-rapidapi-key': process.env.RAPIDAPI_KEY
      }
    }
  );
  return response.data.data.properties;
}

What I Built in 48 Hours

Using this API, I built a working property search app with:

Location autocomplete (powered by /autocomplete)
Property search with filters (powered by /search-property)
Property detail pages (powered by /property-details)
Off-plan project listings (powered by /search-new-projects)
Agent profiles (powered by /agent-details)

Total development time: 48 hours.

With a scraper, this would have taken 3-4 weeks - and it would break every month.

The Numbers

	Scraper	Bayut API
Setup time	3-4 weeks	2 days
Monthly cost	$300-500 (proxies)	$10-50
Uptime	~70%	99.9%
Maintenance	10+ hrs/month	0 hrs/month
Legal risk	High	None

What to Build Next

Once you have the basics working, here are some features to add:

Price alerts - notify users when a property drops in price
Saved searches - let users save their filters
Market analytics - use /transactions to show price trends
Agent comparison - rank agents by listing count and area

Get Started

The Bayut API is available on RapidAPI with a free plan:

🔗 https://rapidapi.com/happyendpoint/api/bayut14/

Full documentation:

📖 https://bayutapi.dev/

Questions? Reach out: happyendpointhq@gmail.com

Built by Happy Endpoint - developer-friendly APIs for real-world data.

🌐 https://happyendpoint.com | 🐦 https://x.com/happyendpointhq

Dubai Real Estate Data - A Developer's Guide to UAE Property APIs

Happy Endpoint — Mon, 30 Mar 2026 08:33:25 +0000

Dubai's real estate market is one of the most dynamic in the world. In 2025, the emirate saw record-breaking transaction volumes, with international investors pouring capital into residential and commercial properties across iconic communities like Dubai Marina, Downtown Dubai, Palm Jumeirah, and Business Bay.

For developers building in this space, the challenge has always been the same: how do you get reliable, structured, real-time property data?

This guide covers everything you need to know about accessing UAE real estate data programmatically in 2026.

The UAE Real Estate Data Landscape

The UAE property market is served by several major portals:

PropertyFinder.ae - one of the largest, with 500K+ listings
Bayut.com - strong in Abu Dhabi and Northern Emirates
Dubizzle - popular for rentals and secondary market
Houza - newer entrant focused on premium properties

None of these offer public APIs. This creates a significant barrier for developers who need property data for their applications.

Your Options for Getting UAE Property Data

Option 1: Build Your Own Scraper

Pros: Full control, no ongoing API costs

Cons:

Weeks of development time
Constant maintenance as sites update
Proxy costs ($100-300/month for reliable proxies)
Legal risk (ToS violations)
Anti-bot systems (Cloudflare, DataDome, etc.)
Unreliable data freshness

Verdict: Only makes sense at very large scale with a dedicated engineering team.

Option 2: Buy Raw Data Dumps

Pros: One-time cost, large dataset

Cons:

Data goes stale immediately
No real-time updates
Often incomplete or poorly structured
No way to query specific criteria

Verdict: Good for historical analysis, not for live applications.

Option 3: Use a Property Data API

Pros:

Real-time data
Structured JSON responses
No infrastructure to maintain
Flexible querying
Predictable costs

Cons:

Ongoing subscription cost
Dependent on third-party uptime

Verdict: Best option for most developers and startups.

The PropertyFinder UAE Data API: A Deep Dive

The best option currently available for UAE property data is the PropertyFinder UAE Data API by Happy Endpoint on RapidAPI.

👉 https://rapidapi.com/happyendpoint/api/propertyfinder-uae-data

What Makes It Stand Out

1. Scale

Over 500,000 active property listings across all UAE emirates. This is one of the largest UAE property datasets available via API.

2. Data Completeness

Each listing includes:

Full property details (type, size, bedrooms, bathrooms)
Pricing in AED
High-quality images
Amenities list
Location with coordinates
Agent name and direct contact information (phone number)
Broker/agency details

3. Market Intelligence

Beyond listings, the API provides:

Historical price trends by community and property type
Community-level market insights
Historical transaction records (sales and rentals)
Developer directory
Community rankings by popularity and affordability

4. Performance

Redis caching ensures fast response times. The API is built for production use, not just prototyping.

5. Coverage

All property categories:

Residential: apartments, villas, townhouses, penthouses, duplexes, hotel apartments
Commercial: offices, retail, warehouses, showrooms, co-working spaces, factories
New developments: off-plan projects, new launches

Key Endpoints Reference

Location Discovery

GET /autocomplete-location?query=Dubai+Marina

Returns location IDs for use in search endpoints. Always start here.

Residential Search

GET /search-rent?location_id=50&property_type=apartment&bedrooms=1,2&price_max=100000
GET /search-buy?location_id=50&property_type=villa&completion_status=ready

Commercial Search

GET /search-commercial-rent?location_id=50&property_type=office-space
GET /search-commercial-buy?location_id=50&property_type=warehouse

New Developments

GET /search-new-projects?location_id=50

Property Details

GET /property-details?property_id=12345678

Market Data

GET /price-trend-of-location?location_id=50&property_type=apartment
GET /property-insight?location_id=51
GET /get-transactions?location_id=50&transaction_type=sold

Agent & Broker Data

GET /search-agents?location_id=50
GET /search-brokers?location_id=50
GET /agent-properties?agent_id=AGENT_ID

Filtering Capabilities

The search endpoints support rich filtering:

Filter	Options
`property_type`	apartment, villa, townhouse, penthouse, duplex, hotel-apartment, office-space, retail, warehouse, shop, showroom, land, factory, co-working-space, farm, and more
`bedrooms`	0 (studio), 1, 2, 3, 4, 5+ (comma-separated)
`bathrooms`	1, 2, 3, 4+ (comma-separated)
`price_min/max`	AED values
`area_min/max`	sqft values
`furnishing`	furnished, unfurnished, partly
`completion_status`	ready, off_plan
`amenities`	balcony, shared_pool, shared_gym, covered_parking, pets_allowed, private_garden, private_pool, security, built_in_wardrobes, view_of_water, view_of_landmark, concierge, bbq_area
`sort`	newest, featured, price_asc, price_desc
`rent_frequency`	yearly, monthly, weekly, daily

What You Can Build

For Consumers:

Property search portals
Rental comparison tools
Neighborhood guides
Property alert systems

For Investors:

ROI calculators
Price trend dashboards
Transaction history tools
Off-plan project trackers

For Businesses:

Commercial space finders
Relocation tools for companies
Corporate housing platforms

For the Industry:

Agent and broker directories
Market research platforms
CRM integrations for real estate agencies

Getting Started Today

Sign up on RapidAPI (free)
Subscribe to the PropertyFinder UAE Data API
Make your first call to /autocomplete-location
Start building

👉 https://rapidapi.com/happyendpoint/api/propertyfinder-uae-data

The UAE real estate market is growing. The tools to build in this space are now accessible. There's no better time to start.

Built by Happy Endpoint - where every API call ends with a smile.

🌐 https://happyendpoint.com | 📧 happyendpointhq@gmail.com