Booking APIbooking.com ↗

"""
Booking.com Property Search and Details API Client
Get your API key from: https://parse.bot/settings
"""

import os
import requests
from datetime import datetime, timedelta
from typing import Optional, List, Dict


class ParseClient:
    """Client for interacting with the Booking.com Parse API"""

    def __init__(self, api_key: Optional[str] = None):
        self.base_url = "https://api.parse.bot"
        self.scraper_id = "347ab358-c792-4521-9ff2-bff0c7f845e0"
        self.api_key = api_key or os.getenv("PARSE_API_KEY")

        if not self.api_key:
            raise ValueError("API key must be provided or set in PARSE_API_KEY environment variable")

    def _call(self, endpoint: str, method: str = "POST", **params) -> dict:
        """
        Make a request to the Parse API

        Args:
            endpoint: The API endpoint name
            method: HTTP method (GET or POST)
            **params: Query/body parameters

        Returns:
            Response JSON as dictionary
        """
        url = f"{self.base_url}/scraper/{self.scraper_id}/{endpoint}"
        headers = {"X-API-Key": self.api_key, "Content-Type": "application/json"}

        if method == "GET":
            response = requests.get(url, headers=headers, params=params)
        elif method == "POST":
            response = requests.post(url, headers=headers, json=params)
        else:
            raise ValueError(f"Unsupported method: {method}")

        response.raise_for_status()
        return response.json()

    def search_properties(
        self,
        destination: str,
        checkin: str,
        checkout: str,
        adults: int = 2,
        rooms: int = 1,
        offset: int = 0,
    ) -> dict:
        """
        Search for properties on Booking.com

        Args:
            destination: Search destination (city, region, or property name)
            checkin: Check-in date (YYYY-MM-DD)
            checkout: Check-out date (YYYY-MM-DD)
            adults: Number of adults (default: 2)
            rooms: Number of rooms (default: 1)
            offset: Results offset for pagination (default: 0)

        Returns:
            Dictionary with 'properties' list and 'total_found' count
        """
        params = {
            "destination": destination,
            "checkin": checkin,
            "checkout": checkout,
            "adults": adults,
            "rooms": rooms,
            "offset": offset,
        }
        return self._call("search_properties", method="GET", **params)

    def get_property_details(self, url: str) -> dict:
        """
        Retrieve detailed information about a specific property

        Args:
            url: The Booking.com property URL

        Returns:
            Dictionary with property name, description, and address
        """
        params = {"url": url}
        return self._call("get_property_details", method="GET", **params)


def format_rating(rating_str: str) -> str:
    """Extract score from rating string"""
    if not rating_str:
        return "No rating"
    parts = rating_str.split()
    return parts[0] if parts else "No rating"


def main():
    """Main function demonstrating a practical property search workflow"""

    # Initialize the client
    client = ParseClient()

    # Define search parameters for a trip next week
    today = datetime.now()
    checkin_date = (today + timedelta(days=7)).strftime("%Y-%m-%d")
    checkout_date = (today + timedelta(days=10)).strftime("%Y-%m-%d")

    destination = "Paris"
    adults = 2
    rooms = 1

    print("=" * 70)
    print(f"BOOKING.COM PROPERTY SEARCH: {destination.upper()}")
    print("=" * 70)
    print(f"Check-in:  {checkin_date}")
    print(f"Check-out: {checkout_date}")
    print(f"Guests:    {adults} adults in {rooms} room(s)")
    print("=" * 70)

    # Step 1: Search for available properties
    print(f"\n[1/2] Searching for properties in {destination}...")

    try:
        search_results = client.search_properties(
            destination=destination,
            checkin=checkin_date,
            checkout=checkout_date,
            adults=adults,
            rooms=rooms,
            offset=0,
        )

        total_found = search_results.get("data", {}).get("total_found", 0)
        properties = search_results.get("data", {}).get("properties", [])

        print(f"✓ Found {total_found} properties matching your criteria")
        print(f"✓ Retrieved {len(properties)} properties in this batch\n")

        if not properties:
            print("No properties available for the selected dates.")
            return

        # Step 2: Display search results and fetch details for top options
        print("[2/2] Retrieving detailed information for top 5 properties...\n")
        print("-" * 70)

        properties_to_detail = properties[:5]
        detailed_results: List[Dict] = []

        for idx, prop in enumerate(properties_to_detail, 1):
            prop_name = prop.get("name", "Unknown Property")
            prop_url = prop.get("url", "")
            prop_price = prop.get("price", "Price not available")
            prop_rating = prop.get("rating", "")
            rating_score = format_rating(prop_rating)

            print(f"\n{idx}. {prop_name}")
            print(f"   Price: {prop_price}")
            print(f"   Rating: {rating_score}")

            # Fetch detailed information for each property
            if prop_url:
                try:
                    details = client.get_property_details(prop_url)
                    detail_data = details.get("data", {})

                    address = detail_data.get("address", "Address not available")
                    description = detail_data.get("description", "No description available")

                    # Truncate long descriptions for display
                    desc_preview = (
                        description[:100] + "..." if len(description) > 100 else description
                    )

                    print(f"   Address: {address}")
                    print(f"   {desc_preview}")

                    detailed_results.append(
                        {
                            "name": detail_data.get("name", prop_name),
                            "address": address,
                            "description": description,
                            "price": prop_price,
                            "rating": rating_score,
                            "url": prop_url,
                        }
                    )
                    print("   ✓ Details loaded")

                except requests.exceptions.RequestException as e:
                    print(f"   ✗ Could not retrieve details: {str(e)}")
                    detailed_results.append(
                        {
                            "name": prop_name,
                            "address": "Not available",
                            "description": "Details could not be retrieved",
                            "price": prop_price,
                            "rating": rating_score,
                            "url": prop_url,
                        }
                    )
            else:
                print("   ✗ No URL available for details")

        # Step 3: Display final summary
        print("\n" + "=" * 70)
        print("SUMMARY: RECOMMENDED PROPERTIES")
        print("=" * 70)

        for idx, prop in enumerate(detailed_results, 1):
            print(f"\n{idx}. {prop['name']}")
            print(f"   Location: {prop['address']}")
            print(f"   Price: {prop['price']}")
            print(f"   Guest Rating: {prop['rating']}")
            if prop['description'] != "Details could not be retrieved":
                desc_preview = (
                    prop['description'][:120] + "..."
                    if len(prop['description']) > 120
                    else prop['description']
                )
                print(f"   About: {desc_preview}")
            print(f"   Link: {prop['url']}")

        print("\n" + "=" * 70)
        print(f"Search Complete: Displayed {len(detailed_results)} of {total_found} properties")
        print("=" * 70)

    except requests.exceptions.RequestException as e:
        print(f"✗ API Error: {str(e)}")
        print("Please check your API key and network connection.")
    except ValueError as e:
        print(f"✗ Configuration Error: {str(e)}")


if __name__ == "__main__":
    main()