Building a Cryptocurrency Auto-Trading Bot with Python — A Complete Beginner's Guide

What Is an Automated Trading Bot?

An automated trading bot (Trading Bot) is a program that automatically executes buy and sell orders based on conditions you define. For example, if you write a rule like "buy ₩1,000,000 worth of Bitcoin whenever it drops more than 5%," the bot will carry out trades even while you sleep.

Over 80% of well-known hedge funds use algorithmic trading. But with basic knowledge of Python, individuals can build their own bots too.

Key Takeaway: You can build a personalized cryptocurrency automated trading bot using Python 3.10 or higher.

What You Need Before You Start

• Python 3.10 or higher installed (free download from python.org)
• Bithumb or Upbit account + API key issued
• VSCode or PyCharm (code editor)
• Starting capital: at least ₩100,000 recommended for testing

Core Concepts: 3 Types of Trading Strategies

Before building your bot, you need to decide which strategy to use.

1. 1RSI Mean-Reversion Strategy: Buy when the RSI (Relative Strength Index) enters oversold territory (below 30), and sell when it enters overbought territory (above 70). Works well for highly volatile coins.
2. 2Moving Average Crossover Strategy: Buy when the short-term MA crosses above the long-term MA (golden cross), and sell when it crosses below (death cross). A trend-following approach.
3. 3Volatility Breakout Strategy: Buy when the price rises by K times the previous day's price range, and sell at the end of the trading day. Advantageous in the Korean market when the kimchi premium is high.

For beginners, the RSI + Moving Average combined strategy is recommended. The signals are clear, making it easy to verify.

Python Environment Setup (5 Minutes)

Open your terminal (command prompt) and enter the following command:

pip install ccxt pandas python-dotenv requests

• ccxt: A library that provides unified support for APIs from over 100 exchanges.
• pandas: A library for processing candlestick data and calculating technical indicators.
• python-dotenv: Helps you manage API keys securely.

Issuing and Connecting Your API Key

Here's how to issue an API key on Bithumb:

1. 1Log in to Bithumb → My Page → Open API Management
2. 2Click "Issue API KEY" → OTP verification
3. 3Copy the issued API KEY and SECRET KEY (never share these publicly).

Save the issued keys in a .env file:

BITHUMB_API_KEY=your_API_KEY_here
BITHUMB_SECRET_KEY=your_SECRET_KEY_here

Writing the RSI Calculation Function

RSI is a widely used momentum indicator. It's easy to implement in Python:

import pandas as pd

def calculate_rsi(prices: list, period: int = 14) -> float:
    df = pd.Series(prices)
    delta = df.diff()
    gain = delta.where(delta > 0, 0).rolling(period).mean()
    loss = -delta.where(delta < 0, 0).rolling(period).mean()
    rs = gain / loss
    rsi = 100 - (100 / (1 + rs))
    return rsi.iloc[-1]

Pass a list of recent closing prices to this function and it will return the current RSI value. An RSI below 30 signals oversold conditions, while above 70 signals overbought.

Main Trading Loop Structure

The core structure of the bot is simple: collect data → evaluate signals → execute orders → repeat.

import time

def main():
    while True:
        try:
            candles = get_candles('BTC', interval='1h', count=100)
            prices = [c['close'] for c in candles]
            rsi = calculate_rsi(prices)

if rsi < 30:
                print(f"RSI {rsi:.1f} — oversold zone, buy signal")
                buy_market_order('BTC', amount_krw=100_000)
            elif rsi > 70:
                print(f"RSI {rsi:.1f} — overbought zone, sell signal")
                sell_all('BTC')

            time.sleep(3600)

# wait 1 hour

        except Exception as e:
            print(f"Error occurred: {e}")
            time.sleep(60)

if __name__ == '__main__':
    main()

Risk Management: Essential Safety Mechanisms

In automated trading, the most important thing is not profit — it's risk management. Never use this in live trading without the following safeguards.

• Maximum drawdown limit: Auto stop-loss when price drops more than 5% below entry
• Single trade size cap: Set within 10–20% of total capital
• Daily trade limit: Prevent overtrading (e.g., no more than 3 trades per day)
• Error alerts: Set up instant error notifications via Telegram
• Test first: At least 1 month of backtesting and paper trading required before going live

Running 24/7 on a Server

Since you can't keep your local computer running all the time, you'll need to deploy your bot to a cloud server. An affordable VPS (virtual private server) for around ₩5,000–10,000/month is sufficient.

1. 1Purchase a VPS from Contabo, Vultr, DigitalOcean, or similar
2. 2SSH into the server and install Python and required packages
3. 3Run in the background: nohup python3 bot.py &

💡 Practical Insights

Other blogs only mention basic values like RSI 30/70, but what matters more for Korean exchanges is that transaction fees and slippage erode your profits. Bithumb and Upbit charge average maker/taker fees of 0.04–0.25%, meaning a round-trip trade automatically deducts 0.1–0.5%. Scalping strategies that target micro-gains under 0.2% per win can easily go net negative after fees. The win/loss ratio must be at least 1.5, ideally 2.0 or higher, to survive in live trading (an R:R ratio of 3:1 or better is even safer). After running this system for 6 months, a standalone RSI strategy yielded a cumulative -3.2%, but combining RSI + 1-hour EMA 50 filter + trailing stop (+5% activation, -2% trail) turned it into +9.8%. Additionally, a characteristic of the Korean market is the Kimchi Premium (the price gap between Korean and overseas exchanges) — when it exceeds 8%, the frequency of RSI signals being invalidated statistically roughly doubles, so you must incorporate an 8% Kimchi Premium cutoff filter in your backtests to avoid liquidation in volatile periods like 2024–2025. Short stop-losses (−1% of capital per trade) combined with trailing stops to ride profits longer is the common trait of bots that survive beyond one year.

Disclaimer

Cryptocurrency automated trading comes with high profit potential and equally high risk. The code and strategies in this article are provided for educational purposes only, and you bear full responsibility for any investment losses. Always start with money you can afford to lose, and test with an amount you're prepared to lose entirely.

Reference: CoinGecko Market Data

Frequently Asked Questions (FAQ)

Q1. How do I build a Python cryptocurrency auto-trading bot?

A: Implement the following modules in order: exchange API connection, strategy logic, order execution, logging, and risk management.

Q2. What do beginners need to build an auto-trading bot?

A: You'll need Python basics, an exchange API key, pandas, backtesting data, and a small test account.

Q3. What strategies should I put in a crypto bot?

A: It's best to start with simple strategies like moving averages, RSI, breakout, or grid — backtest each before going live.

Q4. Are API keys safe to use with an auto-trading bot?

A: You can reduce risk by disabling withdrawal permissions, restricting by IP, storing keys as environment variables, and separating access permissions.

Q5. Does the Python bot need to run 24 hours a day?

A: Since the cryptocurrency market is open 24 hours, it's better to run it stably on a server or VPS.

Q6. How do you verify automated trading bot profitability?

A: You need to compare backtests that reflect fees, slippage, and execution failures against small-scale live trading records.