Construindo um Bot de Trading com Python: Automatize suas Estratégias no Mercado Financeiro

1. Instalação das Dependências

Para iniciar, instale as bibliotecas necessárias usando o gerenciador de pacotes `pip`:

pip install ccxt pandas-ta numpy matplotlib python-dotenv

2. O Código Python do Bot de Trading

Crie um arquivo Python (ex: `trading_bot.py`) e cole o seguinte código:

import ccxt
import pandas as pd
import pandas_ta as ta
import numpy as np
from dotenv import load_dotenv
import os
import time
import logging

# Configuração de logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')

# Carregar variáveis de ambiente
load_dotenv()

class TradingBot:
    def __init__(self):
        self.exchange = ccxt.binance({
            'apiKey': os.getenv('API_KEY'),
            'secret': os.getenv('API_SECRET')
        })
        self.balance = {}
        self.last_order_time = 0
        self.order_frequency = 15 * 60  # 15 minutos em segundos

    def get_market_data(self, symbol, timeframe='1h'):
        try:
            logging.info(f"Fetching market data for {symbol} with timeframe {timeframe}")
            ohlcv = self.exchange.fetch_ohlcv(symbol, timeframe)
            df = pd.DataFrame(ohlcv, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
            return df
        except ccxt.NetworkError as e:
            logging.error(f"Network error while fetching data: {e}")
            return None
        except Exception as e:
            logging.error(f"Error while fetching market data: {e}")
            return None
            
    def analyze_market(self, df):
        logging.info("Analyzing market data...")
        df['SMA_20'] = ta.sma(df['close'], length=20)
        df['RSI'] = ta.rsi(df['close'], length=14)
        return df
        
    def execute_strategy(self, df, symbol):
        logging.info("Executing trading strategy...")
        if df is None or df.empty:
            logging.warning("No market data available to execute strategy.")
            return 'HOLD'
        
        current_time = time.time()
        time_since_last_order = current_time - self.last_order_time

        if time_since_last_order < self.order_frequency:
            logging.info(f"Waiting before next order. Time remaining: {self.order_frequency - time_since_last_order:.2f} seconds")
            return 'HOLD'

        if df['RSI'].iloc[-1] < 30:
            self.place_order(symbol, 'BUY')
            self.last_order_time = current_time
            return 'BUY'
        elif df['RSI'].iloc[-1] > 70:
            self.place_order(symbol, 'SELL')
            self.last_order_time = current_time
            return 'SELL'
        return 'HOLD'
    
    def place_order(self, symbol, order_type):
        try:
           logging.info(f"Placing a {order_type} order for {symbol}")

           #Get the current balance
           self.update_balance()

           # Get the current price
           ticker = self.exchange.fetch_ticker(symbol)
           current_price = ticker['last']
           logging.info(f"Current price of {symbol}: {current_price}")

            # Calculate the quantity to buy/sell (Use 5% of the total balance as an example)
           base_asset = symbol.split('/')[0]
           quote_asset = symbol.split('/')[1]

           if order_type == 'BUY':
                if quote_asset in self.balance and self.balance[quote_asset] > 0:
                    quantity = (self.balance[quote_asset] * 0.05) / current_price
                else:
                    logging.warning(f"Insufficient {quote_asset} balance to place a BUY order")
                    return
           else:
               if base_asset in self.balance and self.balance[base_asset] > 0:
                    quantity = self.balance[base_asset] * 0.05
               else:
                    logging.warning(f"Insufficient {base_asset} balance to place a SELL order")
                    return

           if quantity > 0:
              order = self.exchange.create_market_order(symbol, order_type, quantity)
              logging.info(f"Order placed: {order}")
           else:
              logging.warning("Quantity to place the order is less or equal than zero.")
        except ccxt.InsufficientFunds as e:
            logging.error(f"Insufficient funds to place order: {e}")
        except ccxt.ExchangeError as e:
            logging.error(f"Exchange error while placing order: {e}")
        except Exception as e:
            logging.error(f"Error while placing order: {e}")

    def update_balance(self):
       try:
           self.balance = self.exchange.fetch_balance()['free']
           logging.info(f"Balance updated {self.balance}")
       except Exception as e:
           logging.error(f"Error while updating balance: {e}")

# Uso do bot
bot = TradingBot()
symbol = 'BTC/USDT'
while True:
    data = bot.get_market_data(symbol)
    if data is not None:
        analysis = bot.analyze_market(data)
        decision = bot.execute_strategy(analysis, symbol)
        logging.info(f"Trading decision: {decision}")
    time.sleep(60)  # Executa a cada minuto
        

3. Configuração

Para configurar seu bot, crie um arquivo `.env` na mesma pasta do seu script e adicione suas credenciais da exchange (API Key e API Secret):

API_KEY=sua_api_key
API_SECRET=seu_api_secret
                                        

• Chaves de API: Obtenha suas chaves de API na sua exchange de criptomoedas e insira-as no arquivo `.env`. As chaves de API fornecem acesso à sua conta na exchange, permitindo que seu bot execute ordens de compra e venda.
• Segurança: Não compartilhe suas chaves de API com ninguém e não as inclua diretamente no seu código. Utilize as variáveis de ambiente para garantir a segurança de suas credenciais.
• Testes: Utilize uma conta de teste (se disponível na sua exchange) para testar seu bot antes de usá-lo com dinheiro real.

4. Executando o Script

Abra seu terminal, navegue até o diretório do script e execute o comando:

python trading_bot.py

O bot iniciará a coleta de dados do mercado e executará as ordens de compra e venda de acordo com a estratégia definida. As informações de execução serão registradas no terminal e no log do sistema.

5. Avisos Importantes