Back Market APIbackmarket.fr ↗

"""
Back Market Parse API Client
Get your API key from: https://parse.bot/settings
"""

import os
import requests
from typing import Optional, Any, Dict, List


class ParseClient:
    """Client for interacting with the Back Market API through Parse."""
    
    def __init__(self, api_key: Optional[str] = None):
        self.base_url = "https://api.parse.bot"
        self.scraper_id = "25ea2afe-3b30-4695-b04b-83a719b17b4d"
        self.api_key = api_key or os.getenv("PARSE_API_KEY")
        
        if not self.api_key:
            raise ValueError("API key not provided and PARSE_API_KEY not set")
    
    def _call(self, endpoint: str, method: str = "POST", **params) -> Dict[str, Any]:
        """Make API call to Parse endpoint.
        
        Args:
            endpoint: The API endpoint name
            method: HTTP method (GET or POST)
            **params: Query/body parameters
            
        Returns:
            JSON response 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 HTTP method: {method}")
        
        response.raise_for_status()
        return response.json()
    
    def search_products(self, query: str, page: int = 0, limit: int = 31) -> Dict[str, Any]:
        """Search for products on Back Market by keyword.
        
        Args:
            query: Search keyword (e.g., 'iPhone 15')
            page: Page number (default: 0)
            limit: Number of results per page (default: 31)
            
        Returns:
            Dictionary containing products list, total_hits, page, and nbPages
        """
        return self._call("search_products", method="GET", query=query, page=page, limit=limit)
    
    def get_product_details(self, product_url: Optional[str] = None, 
                           product_id: Optional[str] = None) -> Dict[str, Any]:
        """Extract detailed product information from a Back Market product URL or UUID.
        
        Args:
            product_url: Full Back Market product URL
            product_id: Product UUID
            
        Returns:
            Dictionary containing uuid, title, brand, model, pricing, rating, variants, etc.
        """
        params = {}
        if product_url:
            params["product_url"] = product_url
        if product_id:
            params["product_id"] = product_id
        
        if not params:
            raise ValueError("Either product_url or product_id must be provided")
        
        return self._call("get_product_details", method="GET", **params)
    
    def get_product_reviews(self, product_url: Optional[str] = None, 
                           product_id: Optional[str] = None) -> Dict[str, Any]:
        """Retrieve customer reviews for a product.
        
        Args:
            product_url: Full Back Market product page URL
            product_id: Product UUID
            
        Returns:
            Dictionary containing average_rating, review_count, reviews list, and page
        """
        params = {}
        if product_url:
            params["product_url"] = product_url
        if product_id:
            params["product_id"] = product_id
        
        if not params:
            raise ValueError("Either product_url or product_id must be provided")
        
        return self._call("get_product_reviews", method="GET", **params)


def format_price(price: Optional[float]) -> str:
    """Format price with euro symbol."""
    if price is None:
        return "N/A"
    return f"€{price:,.2f}"


def format_rating(rating: float, review_count: int) -> str:
    """Format rating with star visualization."""
    full_stars = int(rating)
    half_star = "½" if rating % 1 >= 0.5 else ""
    empty_stars = 5 - full_stars - (1 if half_star else 0)
    
    stars = "★" * full_stars + half_star + "☆" * empty_stars
    return f"{stars} {rating:.2f}/5.0 ({review_count:,} reviews)"


def display_product_summary(product: Dict[str, Any]) -> None:
    """Display a summary of a product from search results."""
    print(f"\n📱 {product.get('name', 'Unknown Product')}")
    print(f"   Brand: {product.get('brand', 'N/A')} | Model: {product.get('model', 'N/A')}")
    print(f"   Price: {format_price(product.get('price'))} ", end="")
    
    original = product.get('original_price')
    current = product.get('price', 0)
    if original and original > current:
        savings = ((original - current) / original) * 100
        print(f"(Save {savings:.0f}% from {format_price(original)})")
    else:
        print()
    
    print(f"   {format_rating(product.get('rating', 0), product.get('review_count', 0))}")


def display_detailed_analysis(product_id: str, client: ParseClient) -> None:
    """Fetch and display detailed analysis of a product."""
    try:
        # Get product details
        details = client.get_product_details(product_id=product_id)
        data = details.get('data', {})
        
        print(f"\n   📋 Product Details:")
        print(f"      • UUID: {data.get('uuid')}")
        print(f"      • Title: {data.get('title')}")
        print(f"      • Starting Price: {format_price(data.get('starting_price'))}")
        
        availability = data.get('availability', {})
        in_stock = "✓ In Stock" if availability.get('in_stock') else "✗ Out of Stock"
        can_add = "✓ Addable to Cart" if availability.get('can_add_to_cart') else "✗ Not Available"
        print(f"      • {in_stock} | {can_add}")
        
        # Display variant options
        variants = data.get('variants', [])
        if variants:
            print(f"      • Available Variants:")
            for variant in variants:
                label = variant.get('label', 'Unknown')
                items = variant.get('items', [])
                if items:
                    first_item = items[0]
                    item_label = first_item.get('label', 'N/A')
                    price_info = first_item.get('price', {})
                    price = price_info.get('amount') if isinstance(price_info, dict) else price_info
                    print(f"         - {label}: {item_label} ({format_price(float(price) if price else 0)})")
        
        # Get and display reviews
        print(f"\n   💬 Customer Reviews:")
        reviews_response = client.get_product_reviews(product_id=product_id)
        reviews_data = reviews_response.get('data', {})
        
        avg_rating = reviews_data.get('average_rating', 0)
        review_count = reviews_data.get('review_count', 0)
        reviews = reviews_data.get('reviews', [])
        
        print(f"      Average Rating: {format_rating(avg_rating, review_count)}")
        
        if reviews:
            print(f"      Top Reviews:")
            for idx, review in enumerate(reviews[:3], 1):
                rating = review.get('rating', 0)
                author = review.get('author', 'Anonymous')
                comment = review.get('comment', 'No comment')
                
                if len(comment) > 80:
                    comment = comment[:80] + "..."
                
                star_rating = "★" * rating + "☆" * (5 - rating)
                print(f"      {idx}. [{star_rating}] {author}")
                print(f"         '{comment}'")
        
    except requests.exceptions.RequestException as e:
        print(f"   ⚠️  Error fetching details: {str(e)}")
    except (KeyError, ValueError) as e:
        print(f"   ⚠️  Unexpected response format: {str(e)}")


def main():
    """Practical workflow: search for products and analyze top results with details and reviews."""
    
    client = ParseClient()
    
    print("\n" + "=" * 80)
    print("🛍️  BACK MARKET PRODUCT ANALYZER".center(80))
    print("=" * 80)
    
    # Step 1: Search for products
    search_query = "iPhone 15"
    print(f"\n🔍 Searching for '{search_query}' on Back Market France...")
    
    search_results = client.search_products(query=search_query, limit=5)
    
    if search_results.get('status') != 'success':
        print("❌ Search failed")
        return
    
    search_data = search_results.get('data', {})
    total_hits = search_data.get('total_hits', 0)
    products = search_data.get('products', [])
    total_pages = search_data.get('nbPages', 1)
    
    print(f"✓ Found {total_hits} total products across {total_pages} pages")
    print(f"✓ Analyzing top {len(products)} results...\n")
    
    # Step 2: Analyze each product - get details and reviews
    for idx, product in enumerate(products, 1):
        print("\n" + "-" * 80)
        print(f"RESULT {idx}/{len(products)}")
        print("-" * 80)
        
        display_product_summary(product)
        
        product_id = product.get('uuid')
        if product_id:
            display_detailed_analysis(product_id, client)
    
    print("\n" + "=" * 80)
    print("✓ Analysis Complete!".center(80))
    print("=" * 80 + "\n")


if __name__ == "__main__":
    main()