Python ile Trading Botu Geliştirme: Kapsamlı Rehber 2025

Kripto para piyasalarının 24/7 açık olması, otomatik trading botlarını değerli bir araç haline getiriyor. Bu makalede, Python-Binance kütüphanesini kullanarak basit ama etkili bir trading botu nasıl geliştirebileceğinizi adım adım anlatacağız.

1. Gerekli Kurulumlar ve Hazırlık

İlk olarak, gerekli kütüphaneleri yüklememiz gerekiyor:

pip install python-binance
pip install pandas
pip install numpy

Binance API anahtarlarını oluşturma:

1. Binance hesabınıza giriş yapın
2. API Management bölümüne gidin
3. Create API key’e tıklayın
4. API Key ve Secret Key’i güvenli bir yerde saklayın

from binance.client import Client
from binance.enums import *
import pandas as pd
import numpy as np
import time

# API bilgilerini güvenli bir şekilde saklayın
api_key = 'YOUR_API_KEY'
api_secret = 'YOUR_API_SECRET'

# Binance client'ı başlatma
client = Client(api_key, api_secret)

2. Temel Veri Alma ve İşleme

def get_historical_data(symbol, interval, lookback):
    """
    Geçmiş fiyat verilerini çeker
    
    Parametreler:
    symbol (str): Trading çifti (örn: 'BTCUSDT')
    interval (str): Zaman aralığı (örn: '1h', '15m')
    lookback (str): Ne kadarlık geçmiş veri
    """
    try:
        df = pd.DataFrame(client.get_historical_klines(
            symbol, 
            interval,
            lookback + " ago UTC"
        ))
        
        df = df.iloc[:, :6]
        df.columns = ['Time', 'Open', 'High', 'Low', 'Close', 'Volume']
        df = df.set_index('Time')
        df.index = pd.to_datetime(df.index, unit='ms')
        df = df.astype(float)
        return df
    
    except Exception as e:
        print(f"Veri çekme hatası: {e}")
        return None

3. Basit Trading Stratejisi Oluşturma

Örnek olarak, Hareketli Ortalama (Moving Average) Crossover stratejisi kullanalım:

def calculate_signals(df, short_window=20, long_window=50):
    """
    Trading sinyalleri oluşturur
    """
    df['Short_MA'] = df['Close'].rolling(window=short_window).mean()
    df['Long_MA'] = df['Close'].rolling(window=long_window).mean()
    
    df['Signal'] = 0
    df.loc[df['Short_MA'] > df['Long_MA'], 'Signal'] = 1
    df.loc[df['Short_MA'] < df['Long_MA'], 'Signal'] = -1
    
    return df

def execute_trade(symbol, side, quantity, price):
    """
    Trade işlemini gerçekleştirir
    """
    try:
        if side == "BUY":
            order = client.create_order(
                symbol=symbol,
                side=SIDE_BUY,
                type=ORDER_TYPE_LIMIT,
                timeInForce=TIME_IN_FORCE_GTC,
                quantity=quantity,
                price=str(price)
            )
        else:
            order = client.create_order(
                symbol=symbol,
                side=SIDE_SELL,
                type=ORDER_TYPE_LIMIT,
                timeInForce=TIME_IN_FORCE_GTC,
                quantity=quantity,
                price=str(price)
            )
        
        return order
    
    except Exception as e:
        print(f"Trade hatası: {e}")
        return None

4. Ana Trading Bot Sınıfı

class TradingBot:
    def __init__(self, symbol, interval, lookback):
        self.symbol = symbol
        self.interval = interval
        self.lookback = lookback
        self.position = False
        
    def run(self):
        while True:
            try:
                # Verileri al
                df = get_historical_data(self.symbol, self.interval, self.lookback)
                if df is None:
                    continue
                
                # Sinyalleri hesapla
                df = calculate_signals(df)
                
                # Son sinyali al
                current_signal = df['Signal'].iloc[-1]
                current_price = float(df['Close'].iloc[-1])
                
                # Trading mantığı
                if current_signal == 1 and not self.position:
                    # Alış sinyali
                    quantity = self.calculate_position_size(current_price)
                    order = execute_trade(self.symbol, "BUY", quantity, current_price)
                    if order:
                        self.position = True
                        print(f"ALIŞ: {quantity} {self.symbol} @ {current_price}")
                
                elif current_signal == -1 and self.position:
                    # Satış sinyali
                    quantity = self.get_position_quantity()
                    order = execute_trade(self.symbol, "SELL", quantity, current_price)
                    if order:
                        self.position = False
                        print(f"SATIŞ: {quantity} {self.symbol} @ {current_price}")
                
                # Bekleme süresi
                time.sleep(60)  # 1 dakika bekle
                
            except Exception as e:
                print(f"Bot çalışma hatası: {e}")
                time.sleep(60)
    
    def calculate_position_size(self, price):
        """
        Risk yönetimi ve pozisyon büyüklüğü hesaplama
        """
        balance = float(client.get_asset_balance(asset='USDT')['free'])
        risk_percentage = 0.02  # %2 risk
        position_size = (balance * risk_percentage) / price
        return round(position_size, 6)
    
    def get_position_quantity(self):
        """
        Mevcut pozisyon miktarını öğrenme
        """
        balance = float(client.get_asset_balance(asset=self.symbol.replace('USDT', ''))['free'])
        return round(balance, 6)

5. Botu Çalıştırma

if __name__ == "__main__":
    # Bot parametreleri
    symbol = "BTCUSDT"
    interval = "15m"
    lookback = "1 day"
    
    # Botu başlat
    bot = TradingBot(symbol, interval, lookback)
    bot.run()

Önemli Notlar ve Güvenlik Uyarıları:

1. Risk Yönetimi

• Her zaman küçük miktarlarla test edin
• Stop-loss kullanın
• Risk yönetimi stratejinizi belirleyin

2. Güvenlik Önlemleri

• API anahtarlarınızı güvenli tutun
• IP kısıtlaması kullanın
• Sadece trading izinleri verin

3. Test Etme

• Önce test ağında (testnet) deneyin
• Kağıt üzerinde (paper trading) test edin
• Küçük miktarlarla canlıya geçin

4. Monitoring ve Logging

import logging

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

Bu kod örnekleri ve açıklamalar, temel bir trading botu geliştirmeniz için başlangıç noktası olabilir. Ancak unutmayın ki, gerçek para ile trading yapmadan önce stratejinizi iyice test etmeli ve risk yönetimi konusunda dikkatli olmalısınız.

Ayrıca, bu örnek basit bir strateji kullanmaktadır. Daha karmaşık stratejiler, indikatörler ve risk yönetimi teknikleri ekleyerek botu geliştirebilirsiniz. Her zaman piyasa koşullarını ve yasal düzenlemeleri göz önünde bulundurarak işlem yapın.

Bu makaledeki kod örneklerini geliştirerek ve kendi stratejilerinizi ekleyerek, ihtiyaçlarınıza uygun bir trading botu oluşturabilirsiniz. Başarılar!

Gelişmiş Trading Botu Özellikleri ve İpuçları

Trading botunuzu daha etkili hale getirmek için ekleyebileceğiniz bazı gelişmiş özellikler:

1. Telegram Entegrasyonu

import telegram

def send_telegram_message(bot_token, chat_id, message):
    bot = telegram.Bot(token=bot_token)
    bot.send_message(chat_id=chat_id, text=message)

2. Çoklu Zaman Dilimi Analizi

def multi_timeframe_analysis(symbol):
    timeframes = ['1h', '4h', '1d']
    signals = {}
    
    for tf in timeframes:
        df = get_historical_data(symbol, tf, "1 week")
        signals[tf] = calculate_signals(df)
    
    return signals

3. Volatilite Bazlı Risk Yönetimi

def calculate_volatility(df):
    return df['Close'].pct_change().std()

def adjust_position_size(price, volatility):
    base_size = calculate_position_size(price)
    return base_size * (1 - volatility)

Bu ek özellikler, botunuzun daha güvenli ve verimli çalışmasını sağlayacaktır. Ayrıca, düzenli backtest yaparak stratejinizin performansını değerlendirmeyi unutmayın.