Louis Vuitton Monitor

The Challenge

Louis Vuitton was releasing some highly demanded products, and I saw an opportunity to learn how to build a product monitor that tracks availability changes in real time.

The Technical Solution

I started to design a system to instantly detect and notify about stock updates for Louis Vuitton products.

• Data Scraping: Reverse engineered the API endpoints that fetch product details (name, price, sizes, colors, images).

• Fast Comparison: Utilizing Redis for ultra-low latency storage of previous stock data.

• Change Detection: A logic layer that compares current and previous stock to identify changes for the products.

• Notification: Sending notifications via Discord in the moment an item or size becomes available.

The Reverse-Engineering

The biggest technical challenge was the find the product data. Louis Vuitton does not offer a public API. To get the data like availability, pricing, and product details. I had to reverse-engineer their frontend.

1. Endpoint Search: Using an HTTP interceptor like Proxyman, I monitored traffic on the official website and mobile app to identify the internal API endpoints. All publicly traceable.

2. Data Fetching: The monitor was built to scrape these endpoints. It retrieves the important data for a product, including all available sizes and color variants.

# Construct the URL by joining all product/size IDs for batch querying
results = ",".join(self.size_json.keys())
response = await self.request(
    # API endpoint for fetching availability data
    url=f"/api/catalog/product/{results}/availabilities"
)
if response.status_code != 200:
    await self.logging(message=f"Request blocked | Code: {response.status_code}", level="ERROR")

The Restock Detection

Even with all of the data, the process of checking for a restock needed to be very fast.

• Polling Loop: The core of the monitor ran a basic polling loop, checking product availability every few seconds.

• Redis: To store and compare stock availability, I chose Redis, an in-memory database. Redis offers high read/write speeds which were very important for this project. All other databases would be way too slow.

• Stock Comparison Logic: The script loads the previously known stock status from Redis and compares it to the fresh fetched data.

# Get current stock from the fresh API response
availability = item['inStock']
# Get previous stock status from Redis/previous_availability object
previous_instock = previous_availability[self.pid][color][size_id].get('availability')
if availability: # Current item is IN STOCK (True)
    previous_availability[self.pid][color][size_id]['availability'] = availability
    
    if previous_instock != availability:
        # If previous status was different (e.g., False/None), it's a restock!
        notification_dict[size_name] = {'type': 'Size restocked!', /* ... */}
        need_update = True

As soon as a restock was confirmed, the code would send a notification to discord using a webhook.

Technical Takeaways and Lessons Learned

This project was very helpful to learn about architecting a system for performance.

• Code Optimization: I learned how to optimize my code for speed and reliablity.

• Caching: I learned new things how a cache works and how to setup a data storage with redis.

• System Design for Real-Time Data: I learned how to plan and how to build a fast and reliable system that works without any flaws.

tasks = []
for product in products:
    checker = Checker(delay, product["pid"], product["region"], json_file_lock, code_lock)
    # Create a separate, concurrent task for each product monitor
    tasks.append(asyncio.create_task(checker.get_product_info()))

# Run all monitoring tasks simultaneously
await asyncio.gather(*tasks)

Disclaimer: This project was built strictly for personal and educational purposes. It is not intended for commercial use or public distribution, and all interactions with Louis Vuitton’s systems adhered to legal and ethical standards.