Bitcoin automatic trading system development guide

1. Composition of the development environment

# Install required libraries
pip install ccxt pandas numpy talib TA-Lib python-dotenv schedule websockets flask

• Main tool:
  • CCxt: 100+ Exchange Integration API
  • Pandas: Data analysis
  • TA-LIB: Calculation of technical indicators
  • WebSockets: Receiving real -time data
  • Flask: Dashboard construction

2. Select exchange and set API

# Save API key in .env file
API_KEY = "your_api_key" # API key issued by exchange
API_SECRET = "your_api_secret" # API secret issued by exchange

• Recommended exchange:
  • Binance: High liquidity, REST/Websocket Support
  • Bybit: Specialization of gift transactions
  • Upbeat: Domestic subsidiary stability

3. Collection of chart data

import ccxt

# Initialize Binance API
binance = ccxt.binance({
    'apiKey': API_KEY,  # Set API key
    'secret': API_SECRET,  # Set API secret
    'enableRateLimit': True  # Enable API request limit
})

# Receive real-time OHLCV data (Websocket)
async def fetch_btc_data():
    async with websockets.connect('wss://fstream.binance.com/ws/btcusdt@kline_1m') as ws:
        while True:
            data = await ws.recv()  # Receive real-time data
            print(json.loads(data))  # Print data

4. Trading strategy development

4-1. Implementation of technical indicators

import talib

# Function to calculate technical indicators
def calculate_indicators(df):
    # Calculate 20-day Simple Moving Average (SMA)
    df['MA20'] = talib.SMA(df['close'], timeperiod=20)
    # Calculate 14-day Relative Strength Index (RSI)
    df['RSI'] = talib.RSI(df['close'], timeperiod=14)
    # Calculate MACD (Moving Average Convergence Divergence)
    df['MACD'], _, _ = talib.MACD(df['close'])
    return df

4-2. Sales signal creation logic

# Function to generate trading signals
def generate_signal(df):
    latest = df.iloc[-1]  # Get the latest data
    
    # Dual SMA Strategy
    if latest['MA20'] > latest['MA50'] and df['MA20'].iloc[-2] <= df['MA50'].iloc[-2]:
        return 'BUY'  # Buy signal
    elif latest['MA20'] < latest['MA50'] and df['MA20'].iloc[-2] >= df['MA50'].iloc[-2]:
        return 'SELL'  # Sell signal
    else:
        return 'HOLD'  # Hold signal

5. Risk management system

# Function to calculate position size
def calculate_position_size(balance, risk_per_trade=0.02):
    # Calculate position size based on total capital and risk percentage per trade
    return balance * risk_per_trade

# Function to set stop loss
def set_stop_loss(entry_price, atr, multiplier=1.5):
    # Calculate stop loss based on ATR (Average True Range)
    return entry_price - (atr * multiplier)

6. Order execution module

# Function to execute an order
def execute_order(side, amount, symbol='BTC/USDT'):
    try:
        if side == 'BUY':
            # Execute a market buy order
            order = binance.create_market_buy_order(symbol, amount)
        elif side == 'SELL':
            # Execute a market sell order
            order = binance.create_market_sell_order(symbol, amount)
        print(f"Order Executed: {order}")  # Print order execution log
        return order
    except Exception as e:
        print(f"Order Failed: {e}")  # Print error message if the order fails
        return None

7. Back testing system

# Backtesting function
def backtest_strategy(df, initial_balance=10000):
    balance = initial_balance  # Set initial capital
    position = 0  # Initialize position
    
    for i in range(1, len(df)):
        signal = df['signal'].iloc[i]  # Get trading signal
        price = df['close'].iloc[i]  # Get closing price
        
        if signal == 'BUY' and position == 0:
            # Set position when a buy signal is received
            position = balance / price
            balance = 0
        elif signal == 'SELL' and position > 0:
            # Liquidate position when a sell signal is received
            balance = position * price
            position = 0
            
    return balance  # Return final balance

8. Monitoring & Logging System

import logging

# Logging settings
logging.basicConfig(filename='trading.log', level=logging.INFO)

# Transaction logging function
def log_transaction(order):
    logging.info(f"""
    [Transaction Details]
    Time: {datetime.now()}
    Type: {order['side']}
    Amount: {order['amount']}
    Price: {order['price']}
    Status: {order['status']}
    """)

9. Main function

# Main execution loop
def main():
    while True:
        try:
            df = fetch_realtime_data()  # Fetch real-time data
            df = calculate_indicators(df)  # Calculate technical indicators
            signal = generate_signal(df)  # Generate trading signal
            
            if signal != 'HOLD':
                # Execute an order if there is a trading signal
                amount = calculate_position_size(get_balance())
                execute_order(signal, amount)
                
            time.sleep(60)  # Run at 1-minute intervals
        except KeyboardInterrupt:
            break  # Exit the loop when interrupted by the user

10. Security Enhancement Measures

10-1. API key management

• Never commit the version management system
• Use AWS Secrets Manager or Hashicorp Vault.

10-2. Traffic encryption

binance = ccxt.binance({
    'options': {'adjustForTimeDifference': True},  # Time difference correction
    'proxies': {'https': 'http://10.10.1.10:3128'}  # Proxy settings
})

11. Distribution example

# System service registration (Linux)
[Unit]
Description=Crypto Trading Bot
After=network.target

[Service]
ExecStart=/usr/bin/python3 /path/to/bot.py
Restart=always

[Install]
WantedBy=multi-user.target

📌Core precautions

• Risk restrictions to less than 1% of initial capital
• Exchange API RATE LIMIT must be observed
• Preparation for weekend/holiday market volatility
• Periodically re -evaluation of strategic performance
• Be sure to test more than 2 weeks in virtual environment before actual funds
• It is possible to execute only the actual API address to be issued and applied