Web Scraping & Bots · Lesson

Building a Price Tracker Bot

Develop a bot that monitors product prices on e-commerce sites and sends notifications on price drops.

Building a Price Tracker Bot is a free Web Scraping & Bots lesson on CoddyKit — lesson 1 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Web Scraping & Bots learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

What's a Price Tracker Bot?

Have you ever wanted to know when a product's price drops? A price tracker bot does exactly that!

It's an automated program that regularly checks the price of items on e-commerce websites.

When it detects a price change, especially a drop, it can notify you.

Bot's Core Tasks

Building a price tracker involves several key steps:

Fetch: Get the product page content.
Parse: Extract the price and product details.
Store: Keep track of the last known price.
Compare: Check if the current price is lower.
Notify: Send an alert if a drop is found.

Spotting Product Details

Before we write code, we need to know where the information is on the page.

Using browser developer tools, you'd identify the HTML elements that contain the product's:

Name
Current Price
Product URL

These are crucial for your bot to find the right data.

Getting the Web Page

The first step is to download the web page content. We'll use the requests library for this.

It sends an HTTP GET request to the product URL and retrieves the HTML.

Try running this simple example:

import requests

def fetch_page(url):
    try:
        response = requests.get(url)
        response.raise_for_status() # Check for HTTP errors
        return response.text
    except requests.exceptions.RequestException as e:
        print(f"Error fetching page: {e}")
        return None

if __name__ == "__main__":
    # Example URL (replace with a real product page for testing)
    example_url = "https://example.com/product"
    print(f"Fetching content from: {example_url}")
    # In a real bot, you'd parse this content
    # page_content = fetch_page(example_url)
    # if page_content:
    #     print("Page content fetched successfully (first 200 chars):")
    #     print(page_content[:200])
    # else:
    #     print("Failed to fetch page content.")
    print("Page content fetching logic demonstrated.")

Parsing the Price

Once you have the HTML, you'll use a library like BeautifulSoup to parse it and find the price.

Prices often come with currency symbols or extra text, so we'll need to clean the extracted string to get a numeric value.

Here's a snippet to illustrate:

from bs4 import BeautifulSoup

html_doc = """
<html><body>
  <span class="product-price">$199.99</span>
  <div id="item-name">Cool Gadget</div>
</body></html>
"""

soup = BeautifulSoup(html_doc, 'html.parser')
price_element = soup.find('span', class_='product-price')

if price_element:
    price_string = price_element.get_text()
    # Clean the string to get a float
    cleaned_price = float(price_string.replace('$', '').strip())
    print(f"Extracted Price: {cleaned_price}")
else:
    print("Price element not found.")

Remembering the Price

To track changes, your bot needs to remember the price it last saw. A simple way is to use a file to store this data.

For a basic bot, a JSON file or a simple dictionary in memory can work.

You'll store the product URL and its last known price.

import json

# Example of storing data
product_data = {
    "https://example.com/product1": {
        "name": "Cool Gadget",
        "last_price": 199.99
    },
    "https://example.com/product2": {
        "name": "Awesome Widget",
        "last_price": 49.95
    }
}

# In a real bot, you'd load/save this from a file
# with open('prices.json', 'w') as f:
#     json.dump(product_data, f, indent=2)

print("Product data structure for storage:")
print(json.dumps(product_data, indent=2))

Detecting Price Drops

This is the core logic! After fetching and parsing the new price, you compare it with the stored "last price".

If the new price is lower than the stored price, you've found a deal!

You should also update the stored price with the new one for future comparisons.

current_price = 189.99
stored_price = 199.99
product_name = "Cool Gadget"

if current_price < stored_price:
    print(f"PRICE DROP ALERT! {product_name} is now ${current_price} (was ${stored_price})")
    # Update stored_price = current_price in your data
elif current_price > stored_price:
    print(f"Price increased for {product_name}. Current: ${current_price}, Was: ${stored_price}")
    # Update stored_price = current_price
else:
    print(f"Price for {product_name} remains ${current_price}")

Notifying About Deals

Once a price drop is detected, your bot needs to tell you!

For a simple bot, printing a message to the console is enough. For real-world use, you might:

Send an email
Push a notification to your phone
Send a message to a chat app (e.g., Discord, Telegram)

def send_notification(product_name, old_price, new_price):
    message = (
        f"🚨 Price Drop Alert! 🚨\n"
        f"Product: {product_name}\n"
        f"Old Price: ${old_price:.2f}\n"
        f"New Price: ${new_price:.2f}\n"
        f"Check it out now!"
    )
    print(message)
    # In a real app, you'd integrate email/SMS here

if __name__ == "__main__":
    send_notification("Awesome Headphones", 250.00, 225.00)

Your First Price Tracker

Let's combine these pieces into a basic, runnable price tracker. This example simulates fetching and parsing.

Remember, for a real bot, you'd replace the `mock_fetch_and_parse` with actual requests and BeautifulSoup calls.

import json
import random

# Mock functions for demonstration
def mock_fetch_and_parse(product_url):
    # Simulate different prices
    if "gadget" in product_url:
        return random.choice([199.99, 189.99, 205.00])
    return random.choice([49.95, 45.00, 52.00])

def send_notification(product_name, old_price, new_price):
    print(f"🚨 Price Drop! {product_name} is now ${new_price:.2f} (was ${old_price:.2f})")

# Main logic
def check_price(product_url, product_name, stored_prices):
    current_price = mock_fetch_and_parse(product_url)
    last_price = stored_prices.get(product_url)

    if last_price is None:
        print(f"First check for {product_name}: ${current_price:.2f}")
    elif current_price < last_price:
        send_notification(product_name, last_price, current_price)
    elif current_price > last_price:
        print(f"Price for {product_name} increased to ${current_price:.2f}")
    else:
        print(f"Price for {product_name} remains ${current_price:.2f}")
    
    stored_prices[product_url] = current_price # Update price

if __name__ == "__main__":
    # Simulate stored prices (from a file in a real app)
    my_tracked_items = {
        "https://example.com/gadget": 200.00, # Initial price
        "https://example.com/widget": 50.00
    }

    print("--- First Run ---")
    check_price("https://example.com/gadget", "Cool Gadget", my_tracked_items)
    check_price("https://example.com/widget", "Awesome Widget", my_tracked_items)
    print("\n--- Second Run ---")
    check_price("https://example.com/gadget", "Cool Gadget", my_tracked_items)
    check_price("https://example.com/widget", "Awesome Widget", my_tracked_items)
    print("\nFinal tracked prices:", json.dumps(my_tracked_items, indent=2))

Price Logic Check

Consider a price tracker bot. It last recorded a product price of $50.00. On its next run, it fetches the price as $45.00. What should the bot do?

Recap & Next Steps

You've learned the fundamental steps to build a price tracker bot!

Fetch HTML with requests.
Parse prices with BeautifulSoup.
Store prices (e.g., in a JSON file).
Compare current vs. stored prices.
Notify on price drops.

Next steps include scheduling your bot to run automatically and exploring more advanced notification methods.

Frequently asked questions

Is the “Building a Price Tracker Bot” lesson free?

Yes — the full text of “Building a Price Tracker Bot” is free to read here on the web, and the Web Scraping & Bots course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Web Scraping & Bots course, upgrade to CoddyKit PRO.

What will I learn in “Building a Price Tracker Bot”?

Develop a bot that monitors product prices on e-commerce sites and sends notifications on price drops. You practise Web Scraping & Bots with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Web Scraping & Bots?

No prior experience is required. Web Scraping & Bots on CoddyKit is structured for beginners through advanced learners; this is — lesson 1 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Building a Price Tracker Bot” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Web Scraping & Bots lesson?

Yes. Every Web Scraping & Bots lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

← Back to Web Scraping & Bots