0Pricing
Web Scraping & Bots · Ders

Fiyat Takip Botu Oluşturma

E-ticaret sitelerindeki ürün fiyatlarını izleyen ve fiyat düşüşlerinde bildirim gönderen bir bot geliştirin.

Fiyat Takip Botu Oluşturma, CoddyKit'te ücretsiz bir Web Scraping & Bots dersidir. Bu, 4 dersinin 1. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Web Scraping & Bots öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Web Scraping & Bots kursu toplamda 4 dersten oluşur.

Bu dersin bazı bölümleri henüz çevrilmemiş olup İngilizce olarak gösterilmektedir.

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.

Sıkça Sorulan Sorular

“Fiyat Takip Botu Oluşturma” dersi ücretsiz mi?

Evet — “Fiyat Takip Botu Oluşturma” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Web Scraping & Bots kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Web Scraping & Bots kursu toplamda 4 dersten oluşur.

“Fiyat Takip Botu Oluşturma” dersinde ne öğreneceğim?

E-ticaret sitelerindeki ürün fiyatlarını izleyen ve fiyat düşüşlerinde bildirim gönderen bir bot geliştirin. Web Scraping & Bots ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Web Scraping & Bots öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Web Scraping & Bots, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 1. dersidir.

“Fiyat Takip Botu Oluşturma” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu Web Scraping & Bots dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Web Scraping & Bots dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

  1. Fiyat Takip Botu Oluşturma
  2. Sosyal Medya İzleyicisi Oluşturma
  3. Botları Bulut Platformlarına Dağıtma
  4. Uyarı ve Bildirim Gönderme
← Web Scraping & Bots Sayfasına Dön