How I Built a Python Bot That Makes $500/Month Passively

How I Built a Python Bot That Makes $500/Month Passively

Let me set realistic expectations immediately: this title is technically accurate, but the word "passively" deserves an asterisk. The bot runs without me watching it. It generates revenue without me doing anything hour-to-hour. But it required 6 weeks to build, takes 2–3 hours per month to maintain, and took 4 months to reach $500/month.

That's still worth understanding. Here's the real story.

What the Bot Does

I built a niche price alert service for electronics resellers.

The system:

1. Scrapes prices from electronics retail pages every 30 minutes
2. Compares current prices to historical data
3. Detects unusual discounts (typically clearance or pricing errors)
4. Sends instant Telegram alerts to subscribers when deals appear
5. Subscribers pay $15/month for access to the alert feed

At 35+ paying subscribers, the math works.

Why this worked:

• Electronics resellers (people who buy discounted items and resell at profit) will pay for a reliable deal feed
• The automation is genuinely useful — manual price checking 24/7 is impossible
• The technical barrier keeps competition low

The Technical Architecture

Component 1: The Scraper

import requests
from bs4 import BeautifulSoup
import time
import hashlib
from pathlib import Path
import json
from datetime import datetime

def scrape_product(url: str) -> dict | None:
    headers = {
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
    }
    
    try:
        response = requests.get(url, headers=headers, timeout=15)
        response.raise_for_status()
        soup = BeautifulSoup(response.text, "html.parser")
        
        # Extract price (selector varies by site)
        price_el = soup.select_one(".a-price-whole")
        if not price_el:
            return None
        
        price_text = price_el.text.strip().replace(",", "")
        price = float(price_text)
        
        title_el = soup.select_one("#productTitle")
        title = title_el.text.strip() if title_el else "Unknown"
        
        return {
            "url": url,
            "title": title,
            "price": price,
            "scraped_at": datetime.now().isoformat(),
        }
    
    except Exception as e:
        print(f"Error scraping {url}: {e}")
        return None

For the full scraping guide, see our Python web scraping guide.

Component 2: Price History and Deal Detection

import sqlite3
from dataclasses import dataclass

def setup_database():
    conn = sqlite3.connect("prices.db")
    conn.execute("""
        CREATE TABLE IF NOT EXISTS price_history (
            id INTEGER PRIMARY KEY,
            url TEXT,
            title TEXT,
            price REAL,
            scraped_at TEXT
        )
    """)
    conn.commit()
    return conn

def save_price(conn, product: dict):
    conn.execute(
        "INSERT INTO price_history (url, title, price, scraped_at) VALUES (?, ?, ?, ?)",
        (product["url"], product["title"], product["price"], product["scraped_at"])
    )
    conn.commit()

def detect_deal(conn, url: str, current_price: float) -> bool:
    # Get average price over last 30 days
    cursor = conn.execute("""
        SELECT AVG(price), MIN(price) 
        FROM price_history 
        WHERE url = ? 
        AND scraped_at > datetime('now', '-30 days')
    """, (url,))
    
    avg_price, min_price = cursor.fetchone()
    if avg_price is None or avg_price == 0:
        return False
    
    # Alert if current price is 25%+ below 30-day average
    discount = (avg_price - current_price) / avg_price
    return discount >= 0.25

Component 3: The Telegram Bot

import asyncio
from telegram import Bot
from telegram.error import TelegramError

class AlertBot:
    def __init__(self, token: str, channel_id: str):
        self.bot = Bot(token=token)
        self.channel_id = channel_id
    
    async def send_deal_alert(self, product: dict, discount_pct: float):
        message = (
            f"🔥 **DEAL ALERT**\n\n"
            f"📦 {product['title']}\n"
            f"💰 Current: ${product['price']:.2f}\n"
            f"📉 {discount_pct:.0%} below 30-day average\n"
            f"🔗 {product['url']}"
        )
        
        try:
            await self.bot.send_message(
                chat_id=self.channel_id,
                text=message,
                parse_mode="Markdown"
            )
        except TelegramError as e:
            print(f"Failed to send alert: {e}")

pip install python-telegram-bot

Component 4: The Main Loop

import schedule
import time

def run_price_check():
    conn = setup_database()
    alert_bot = AlertBot(token=TELEGRAM_TOKEN, channel_id=CHANNEL_ID)
    
    for url in PRODUCT_URLS:
        product = scrape_product(url)
        if not product:
            continue
        
        if detect_deal(conn, url, product["price"]):
            avg = get_avg_price(conn, url)
            discount = (avg - product["price"]) / avg
            asyncio.run(alert_bot.send_deal_alert(product, discount))
        
        save_price(conn, product)
        time.sleep(2)  # Polite delay between requests

schedule.every(30).minutes.do(run_price_check)

print("Bot running...")
while True:
    schedule.run_pending()
    time.sleep(30)

The Monetization System

Telegram premium channels are the simplest monetization for a bot like this:

• Create a private Telegram channel
• Use a payment bot (like @SellerBot) to automate subscriptions
• Members pay monthly to stay in the channel

For more advanced monetization, a proper subscription system looks like:

# Simplified subscription check
def is_active_subscriber(telegram_user_id: int) -> bool:
    conn = sqlite3.connect("subscribers.db")
    cursor = conn.execute("""
        SELECT expires_at FROM subscribers 
        WHERE telegram_id = ? AND expires_at > datetime('now')
    """, (telegram_user_id,))
    return cursor.fetchone() is not None

Revenue path I used:

1. Built the bot and ran it free for 2 weeks — proved it worked
2. Started a Telegram channel with "paid access coming soon"
3. Launched at $10/month (introductory price)
4. Raised to $15/month after 20 subscribers
5. Month 4: 35+ subscribers = ~$525/month

What Makes This Sustainable

It solves a real problem. Price monitoring 24/7 is impossible manually. Resellers will pay for reliable alerts.

The barrier is technical. Most resellers aren't developers. The tool is valuable and non-obvious to replicate.

Maintenance is manageable. The main ongoing work: updating CSS selectors when retail sites redesign, monitoring server uptime, and handling subscriber payments.

The economics scale slowly. More subscribers = same server cost. But you hit limits — 100 paying subscribers at $15/month is $1,500/month, which requires more reliable infrastructure.

What Didn't Work

First attempt: social media automation. I built Instagram automation tools in 2023. Worked for 3 months, then Instagram updated their detection. Account bans, lost subscribers, zero income. Platform risk is real.

Second attempt: Etsy price monitoring. Same concept for handmade goods. The data was too sparse for meaningful deal detection. Abandoned after 3 months.

The lesson: Solve a problem in a market where people are already spending money and where pricing data is meaningful.

Realistic Income from Python Bots

Frequently Asked Questions

Can Python bots generate passive income?

Yes, with realistic expectations. $200–$2,000/month is achievable. "Passive" means minimal day-to-day work, not zero work.

What bots can make money?

Alert/notification services, niche SaaS tools, freelance automation, data products, and content automation are the most reliable categories.

Is building income bots ethical?

Depends on what it does. Solving real problems = ethical and sustainable. Manipulating platforms = unethical and unsustainable.

How long to first dollar?

3–6 months for a SaaS tool. 1–2 months for freelance automation services.

Final Thoughts

Python automation income is real, but it's builder income, not passive income in the get-rich-quick sense. The $500/month took 6 weeks to build and 4 months to reach that revenue level. That's a part-time job's worth of effort up front.

What makes it compelling: the work is interesting, the skills compound (each automation project teaches something useful), and the potential scales without proportional time investment once the system runs.

For the Python automation fundamentals this project relies on, see our Python automation scripts guide. For understanding the web scraping component in depth, our Python web scraping guide covers the BeautifulSoup patterns used here. And for deploying this kind of bot to run 24/7 without your laptop, our Python AWS deployment guide covers cloud hosting options.