DEV Community

Timevolt
Timevolt

Posted on

How I Built a Stock Market Trading Bot in Python – My 'Back to the Future' Adventure

#trading #finance #crypto #stocks

The Quest Begins (The "Why")

Here's the thing: I was tired of staring at candlestick charts at 2 a.m., second‑guessing whether to buy or sell, and watching my portfolio swing like a pendulum while I slept. I kept thinking, “If only I could automate this like Doc Brown automates his DeLorean.” The idea wasn’t just about making money; it was about reclaiming my sleep and turning trading into a repeatable experiment instead of a gut‑feel gamble.

So I grabbed my laptop, brewed a pot of coffee, and set out to build a bot that could fetch market data, decide when to act, and place orders—all while I caught some Zs. The first version? A clumsy script that pulled data with requests, slapped together a moving‑average crossover, and fired off market orders with zero error handling. Spoiler: it crashed more often than it traded.

The Revelation (The Insight)

The breakthrough came when I stopped treating the bot like a one‑off hack and started thinking of it as a tiny trading system with three clear layers:

  1. Data acquisition – reliable, timestamped, and rate‑limit aware.
  2. Signal generation – pure functions that take a DataFrame and return a signal (buy, sell, hold).
  3. Execution & risk management – a thin wrapper around the exchange API that checks position size, stop‑loss, and respects the exchange’s rules.

Once I separated those concerns, the code became readable, testable, and—most importantly—debuggable. I could swap in a new indicator without touching the order‑placement logic, and I could back‑test strategies on historical data before risking real capital.

Wielding the Power (Code & Examples)

The “Before” – a fragile monolith 

import requests, time
import pandas as pd

API_URL = "https://api.example.com/klines?symbol=BTCUSDT&interval=1h&limit=100"

def get_data():
    resp = requests.get(API_URL)
    return resp.json()

def simple_ma_crossover(df):
    df['ma_short'] = df['close'].rolling(5).mean()
    df['ma_long']  = df['close'].rolling(20).mean()
    if df['ma_short'].iloc[-1] > df['ma_long'].iloc[-1] and df['ma_short'].iloc[-2] <= df['ma_long'].iloc[-2]:
        return "buy"
    if df['ma_short'].iloc[-1] < df['ma_long'].iloc[-1] and df['ma_short'].iloc[-2] >= df['ma_long'].iloc[-2]:
        return "sell"
    return "hold"

while True:
    raw = get_data()
    df = pd.DataFrame(raw, columns=['time','open','high','low','close','volume'])
    df['time'] = pd.to_datetime(df['time'], unit='ms')
    signal = simple_ma_crossover(df)
    if signal == "buy":
        requests.post("https://api.example.com/order", json={"symbol":"BTCUSDT","side":"BUY","type":"MARKET","quantity":0.001})
    elif signal == "sell":
        requests.post("https://api.example.com/order", json={"symbol":"BTCUSDT","side":"SELL","type":"MARKET","quantity":0.001})
    time.sleep(60)
Enter fullscreen mode Exit fullscreen mode

What went wrong?

  • No error handling – a network hiccup raised an exception and killed the loop.
  • No rate‑limit respect – the exchange banned my IP after a few hundred calls.
  • Position sizing was hard‑coded; a 0.001 BTC order could be too big or too small depending on account balance.
  • The strategy was evaluated on the most recent candle only, opening the door to look‑ahead bias if I ever added more complex indicators.

The “After” – a clean, layered bot 

import ccxt, pandas as pd, ta, time, logging
from dataclasses import dataclass

logging.basicConfig(level=logging.INFO, format='%(asctime)s %(levelname)s %(message)s')

# -------------------------------------------------
# 1️⃣ Data layer – robust fetch with retry & rate limit
# -------------------------------------------------
def fetch_ohlcv(exchange: ccxt.Exchange, symbol: str, timeframe: str, limit: int = 100) -> pd.DataFrame:
    for attempt in range(3):
        try:
            ohlcv = exchange.fetch_ohlcv(symbol, timeframe, limit=limit)
            df = pd.DataFrame(ohlcv, columns=['timestamp','open','high','low','close','volume'])
            df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
            df.set_index('timestamp', inplace=True)
            return df
        except (ccxt.NetworkError, ccxt.ExchangeError) as e:
            logging.warning(f"Fetch attempt {attempt+1} failed: {e}")
            time.sleep(2 ** attempt)  # exponential backoff
    raise RuntimeError("Failed to fetch OHLCV after retries")

# -------------------------------------------------
# 2️⃣ Signal layer – pure function, easy to unit‑test
# -------------------------------------------------
def generate_signal(df: pd.DataFrame) -> str:
    # Example: EMA crossover with a volatility filter
    df['ema_fast'] = ta.trend.ema_indicator(df['close'], window=12)
    df['ema_slow'] = ta.trend.ema_indicator(df['close'], window=26)
    df['atr'] = ta.volatility.average_true_range(df['high'], df['low'], df['close'], window=14)

    # Only trade when volatility is above a threshold (avoid choppy markets)
    if df['atr'].iloc[-1] < df['atr'].mean() * 0.5:
        return "hold"

    if df['ema_fast'].iloc[-1] > df['ema_slow'].iloc[-1] and df['ema_fast'].iloc[-2] <= df['ema_slow'].iloc[-2]:
        return "buy"
    if df['ema_fast'].iloc[-1] < df['ema_slow'].iloc[-1] and df['ema_fast'].iloc[-2] >= df['ema_slow'].iloc[-2]:
        return "sell"
    return "hold"

# -------------------------------------------------
# 3️⃣ Execution layer – risk‑managed order placement
# -------------------------------------------------
@dataclass
class BotConfig:
    symbol: str = "BTC/USDT"
    timeframe: str = "1h"
    risk_per_trade: float = 0.01   # 1 % of equity
    max_position: float = 0.01     # hard cap on BTC amount

def place_order(exchange: ccxt.Exchange, signal: str, config: BotConfig):
    balance = exchange.fetch_balance()
    equity = balance['total']['USDT']
    price = exchange.fetch_ticker(config.symbol)['last']
    # Convert risk % to BTC amount, respecting max_position
    risk_usdt = equity * config.risk_per_trade
    amount = min(risk_usdt / price, config.max_position)

    if signal == "buy":
        order = exchange.create_market_buy_order(config.symbol, amount)
        logging.info(f"BUY {amount:.6f} {config.symbol} @ {price:.2f}")
    elif signal == "sell":
        order = exchange.create_market_sell_order(config.symbol, amount)
        logging.info(f"SELL {amount:.6f} {config.symbol} @ {price:.2f}")
    else:
        logging.info("HOLD – no order placed")

# -------------------------------------------------
# Main loop – gluing it all together
# -------------------------------------------------
def run_bot():
    exchange = ccxt.binance({'enableRateLimit': True})  # built‑in rate limit handling
    config = BotConfig()

    while True:
        try:
            df = fetch_ohlcv(exchange, config.symbol, config.timeframe)
            signal = generate_signal(df)
            place_order(exchange, signal, config)
        except Exception as e:
            logging.error(f"Unexpected error: {e}")
        time.sleep(60)  # wait for next candle

if __name__ == "__main__":
    run_bot()
Enter fullscreen mode Exit fullscreen mode

Why this feels like a victory:

  • The exchange object from ccxt automatically respects rate limits, so I no longer get banned.
  • Fetching data is wrapped in a retry loop with exponential backoff—transient hiccups just pause the bot, not kill it.
  • The signal function is pure; I can unit‑test it with a static DataFrame and know exactly what it will return.
  • Position sizing is now a function of account equity and a configurable risk percent, making the bot portable across accounts of any size.
  • Logging gives me a clear audit trail without cluttering the console.

Traps to Avoid (the “bosses” on our quest)

  1. Over‑fitting to historical data – Just because a strategy shone on the last six months doesn’t guarantee future success. Always walk‑forward test or use out‑of‑sample periods.
  2. Look‑ahead bias – Never use future information (like tomorrow’s high) to calculate today’s indicator. Stick to rolling windows that only reference past candles.
  3. Ignoring exchange fees and slippage – A strategy that looks profitable on paper can evaporate once you factor in taker/maker fees.

Why This New Power Matters

Now I can let the bot run while I’m asleep, at work, or even hiking in the woods. I’ve turned a chaotic, emotion‑driven hobby into a repeatable experiment I can tweak, measure, and improve. The same skeleton works for stocks (via ccxt’s‑like wrappers or alpaca-trade-api), crypto, or futures—just swap the symbol and adjust the timeframe.

More than the code, the mindset shift is the real win: treat trading as a systems problem, not a gut feeling. Every line of code becomes a lever you can pull to adjust risk, increase efficiency, or explore new ideas.

Your Turn

Ready to start your own quest? Grab an exchange API key (testnet first!), copy the skeleton above, and try swapping the EMA crossover for something else—maybe an RSI‑based mean‑reversion or a Bollinger Band breakout.

What indicator are you most excited to experiment with? Drop your ideas in the comments, and let’s build the next generation of trading bots together! 🚀

Top comments (0)