DEV Community

Cover image for How to Build a Crypto Trading Bot in Python — Step-by-Step Guide with Source Code
Kamran
Kamran

Posted on • Originally published at matrixtrak.com

How to Build a Crypto Trading Bot in Python — Step-by-Step Guide with Source Code

#python #trading #crypto #showdev

Building a real-time crypto trading bot sounds like a weekend project — until exchange APIs return cryptic errors, WebSocket connections drop mid-trade, and rate limits turn your strategy into a debugging nightmare. After building my own bot from scratch, I learned that reliability is what separates a hobby script from a system that actually survives in production.

This guide walks through the entire process: modular bot architecture, a real-time trading loop, plug-in strategies, backtesting, paper trading, and deployment to a $5 VPS — with production reliability patterns baked in from day one.

Full source code included — the free AlgoTrak Backtest Lab on GitHub has 5 classic strategies, a complete backtesting engine, and Jupyter notebooks to get started immediately.

Architecture Overview

Before writing code, here's the modular structure we'll build:

crypto_bot/
├── strategies/
│   ├── rsi_strategy.py
│   ├── macd_strategy.py
│   └── ...          # Plug in your own
├── core/
│   ├── trader.py    # Data fetching + order execution
│   └── logger.py    # File + DB logging
├── config/
│   └── settings.json
├── cli.py           # Entry point
├── bot.py           # Main loop
└── logs/
Enter fullscreen mode Exit fullscreen mode

Each strategy is a standalone Python class. The trader handles exchange communication. The CLI lets you switch between strategies, symbols, and modes (paper vs live) without touching code.

Real-Time Trading Loop

Here's the core loop that runs every candle interval:

while True:
    df = fetch_ohlcv(symbol, interval)
    signal = strategy.evaluate(df)
    if signal == "BUY":
        trader.buy(symbol, quantity)
    elif signal == "SELL":
        trader.sell(symbol, quantity)
    sleep(next_candle_time())
Enter fullscreen mode Exit fullscreen mode

Three key points:

  1. fetch_ohlcv() pulls the latest OHLCV candle data from the exchange
  2. Your strategy evaluates the last N candles and returns a signal
  3. Orders execute only on valid signals — no guesswork

Modular Strategy Example (RSI)

Strategies follow a simple class interface. Here's a complete RSI strategy:

import pandas as pd
import pandas_ta as ta

class RSIStrategy:
    def __init__(self, period=14, overbought=70, oversold=30):
        self.period = period
        self.overbought = overbought
        self.oversold = oversold

    def evaluate(self, df: pd.DataFrame) -> str:
        df['rsi'] = ta.rsi(df['close'], length=self.period)
        last_rsi = df['rsi'].iloc[-1]

        if last_rsi < self.oversold:
            return "BUY"
        elif last_rsi > self.overbought:
            return "SELL"
        return "HOLD"
Enter fullscreen mode Exit fullscreen mode

To add a MACD strategy or any other, just create a new class with the same evaluate(df) -> str interface. The bot auto-discovers strategies — zero wiring required.

CLI Control

Start the bot with any strategy, symbol, and mode from the command line:

import argparse

parser = argparse.ArgumentParser()
parser.add_argument('--symbol', type=str, required=True)
parser.add_argument('--strategy', type=str, required=True)
parser.add_argument('--mode', choices=['paper', 'live'], default='paper')
args = parser.parse_args()

bot = TradingBot(symbol=args.symbol, strategy=args.strategy, mode=args.mode)
bot.run()
Enter fullscreen mode Exit fullscreen mode

Usage:

python cli.py --symbol BTCUSDT --strategy rsi --mode paper
Enter fullscreen mode Exit fullscreen mode

Always start in paper mode. Simulate trades first, review the logs, then switch to live once you're confident.

Backtesting

The bot supports historical simulation from CSV data or direct Binance fetch. Paper trading logs every simulated order:

[2025-04-23 14:22:01] BUY BTCUSDT at 62410.5 [RSI: 29.7]
[2025-04-23 16:00:00] SELL BTCUSDT at 63120.3 [RSI: 71.2]
Enter fullscreen mode Exit fullscreen mode

Once your strategy performs well in backtests, switch to paper mode to validate real-time execution without risking capital.

Deployment on a $5 VPS

This bot runs on a $5/month DigitalOcean droplet with minimal resource usage:

  1. Install Python 3.10+, pip, and virtualenv
  2. Clone the repo and install dependencies
  3. Run in a tmux or screen session for persistence
  4. Monitor logs: tail -f logs/session.log

That's it — the bot runs 24/7 with negligible CPU and memory overhead.

Production Reality: What Hobby Scripts Miss

The guide above gets you a working bot. But production is where exchange APIs show their teeth:

  • Exchange API errors — Binance -1021 (clock drift), Bybit 10006 (timestamp), Kraken aggressive rate limits. Every exchange has unique failure modes with minimal documentation.
  • Rate limiting — Hit a rate limit mid-trade and your bot gets temporarily banned. Without exponential backoff with jitter, synchronized retries amplify the problem.
  • WebSocket disconnects — Exchanges reset connections every 24 hours. Networks glitch. Without auto-reconnection and sequence tracking, you miss trades silently.
  • Timestamp drift — Server clocks drift. Signed requests fail. Orders don't execute. A 30-second NTP sync fixes it; a drift monitoring tool prevents recurrence.

These aren't edge cases — they're the daily reality of running a trading bot in production.

For a deep dive into each of these topics:

Build It Yourself: Free Resources

Resource What it gives you
AlgoTrak Backtest Lab 5 classic strategies, backtesting engine, Jupyter notebooks (MIT, free)
Trading Bot Reliability Lab 9 articles: exchange errors, WebSocket, crash recovery, and more
Bot Reliability Checklist 20-point pre-flight checklist before going live
WebSocket Reconnection Kit Reconnection templates, heartbeat configs, state recovery

Production-Grade Alternative: AlgoTrak

If you want to skip the months of build-and-debug and deploy a professionally hardened bot today:

Feature Build from scratch AlgoTrak
Development time 3–6 months Deploy in 1 hour
Trading strategies 1–3 basic 14 configurable
Exchange support 1 (Binance) 5 exchanges (Binance, Bybit, Kraken, KuCoin, OKX)
Risk management Manual Full module — 3 sizing methods, SL/TP, circuit breaker
Test suite Write your own 51 tests — strategies, sizing, integration
Deployment Manual Docker + systemd — one command
Documentation What you write 200-page professional guide
Price Months of your time $179 one-time

See AlgoTrak Details →

Final Thoughts

Building a crypto trading bot from scratch teaches you more about exchange API reliability than any tutorial can. You'll encounter rate limits, signature errors, WebSocket drops, and timestamp drift — all the production realities that separate a hobby script from a system that survives.

The free backtest lab on GitHub gets you running in minutes. If you'd rather deploy a production-grade bot with 14 strategies, 5 exchanges, and full risk management, AlgoTrak is the fastest path.

Either way — build it or buy it — handle production reliability before your first real trade.

Originally published at matrixtrak.com/blog/how-i-built-a-real-time-crypto-trading-bot-in-python

For the full guide with additional production code examples, in-depth explanations, and downloadable resources, check out the original post on MatrixTrak.

Top comments (0)