1. Trading Bot mit Phyton programmieren

Python ist sehr gut geeignet um Trading Bots zu programmieren, besonders im Bereich Retail-Trading. Die Programmiersprache ist bekannt dafür, dass sie nicht so schwer zu erlernen ist und es viele verfügbare Bibliotheken gibt, die speziell für den Finanzmarkt entwickelt wurden.

Besonders für Algo Trading ist Python wegen der vielen Tools wie pandas, NumPy, TA-Lib und ccxt (für Krypto-Börsen) weit verbreitet.

Phyton Trading Bot Beispiel für Trendfolge:

Für diesen Code brauchst Du die Bibliotheken: pip install ccxt pandas.

import ccxt
import pandas as pd
import time

# Börsenanbindung (Binance als Beispiel)
exchange = ccxt.binance({
    'apiKey': 'DEINE_API_KEY',
    'secret': 'DEIN_SECRET_KEY',
})

# Funktion, um historische Daten abzurufen
def fetch_ohlcv(symbol, timeframe='1h', limit=100):
    data = exchange.fetch_ohlcv(symbol, timeframe=timeframe, limit=limit)
    df = pd.DataFrame(data, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
    df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
    return df

# Einfache Trendfolge-Strategie basierend auf gleitenden Durchschnitten
def moving_average_strategy(symbol, short_window=20, long_window=50):
    df = fetch_ohlcv(symbol)
    df['SMA20'] = df['close'].rolling(window=short_window).mean()
    df['SMA50'] = df['close'].rolling(window=long_window).mean()

    # Kaufsignal: Wenn SMA20 über SMA50 steigt
    if df['SMA20'].iloc[-1] > df['SMA50'].iloc[-1]:
        return 'buy'
    # Verkaufssignal: Wenn SMA20 unter SMA50 fällt
    elif df['SMA20'].iloc[-1] < df['SMA50'].iloc[-1]:
        return 'sell'
    else:
        return 'hold'

# Funktion, um Trades auszuführen
def execute_trade(signal, symbol, amount):
    if signal == 'buy':
        print(f"Kaufe {amount} von {symbol}")
        # exchange.create_market_buy_order(symbol, amount)  # Kommentiere aus für echten Handel
    elif signal == 'sell':
        print(f"Verkaufe {amount} von {symbol}")
        # exchange.create_market_sell_order(symbol, amount)  # Kommentiere aus für echten Handel
    else:
        print("Keine Aktion")

# Endlos-Schleife, die alle 15 Minuten überprüft
symbol = 'BTC/USDT'
amount = 0.001  # Menge des zu handelnden Assets
while True:
    signal = moving_average_strategy(symbol)
    execute_trade(signal, symbol, amount)
    time.sleep(900)  # 15 Minuten warten

Wichtig: Dieses Bot-Skript hat kein eingebautes Risikomanagement. Den Stop-Loss und Take-Profit musst Du noch entsprechend Deinem individuellen Risikoansatz hinzufügen.

2. Nutze JavaScript für Deinen Bot

Auch JavaScript ist in Kombination mit Node.js, eine gern benutzte Programmiersprache, vor allem wenn Krypto Bots programmiert werden sollen. Viele Web-basierte Trading-Plattformen und APIs haben JavaScript-Integrationen, weshalb viele Trader gerne auf JavaScript zurückgreifen.

JavaScript Trading Bot Beispiel:

Installiere Node.js und die benötigten Pakete: npm install ccxt.

const ccxt = require('ccxt');

// API-Schlüssel und Secret für Binance (ersetzen durch deine eigenen)
const exchange = new ccxt.binance({
    apiKey: 'DEINE_API_KEY',
    secret: 'DEIN_SECRET_KEY',
});

// Funktion, um historische Daten abzurufen
async function fetchOHLCV(symbol, timeframe = '1h', limit = 100) {
    const data = await exchange.fetchOHLCV(symbol, timeframe, { limit });
    return data.map(candle => ({
        timestamp: candle[0],
        open: candle[1],
        high: candle[2],
        low: candle[3],
        close: candle[4],
        volume: candle[5]
    }));
}

// Berechnung des gleitenden Durchschnitts
function calculateSMA(data, window) {
    return data.map((item, index, array) => {
        if (index < window) return null;
        const subset = array.slice(index - window, index);
        const sum = subset.reduce((acc, val) => acc + val.close, 0);
        return sum / window;
    });
}

// Einfache Trendfolge-Strategie
async function movingAverageStrategy(symbol) {
    const ohlcv = await fetchOHLCV(symbol);
    const sma20 = calculateSMA(ohlcv, 20);
    const sma50 = calculateSMA(ohlcv, 50);

    const lastSMA20 = sma20[sma20.length - 1];
    const lastSMA50 = sma50[sma50.length - 1];

    if (lastSMA20 && lastSMA50) {
        if (lastSMA20 > lastSMA50) {
            return 'buy';
        } else if (lastSMA20 < lastSMA50) {
            return 'sell';
        }
    }
    return 'hold';
}

// Funktion, um Trades auszuführen
async function executeTrade(signal, symbol, amount) {
    if (signal === 'buy') {
        console.log(`Kaufe ${amount} von ${symbol}`);
        // await exchange.createMarketBuyOrder(symbol, amount); // Kommentiere aus für echten Handel
    } else if (signal === 'sell') {
        console.log(`Verkaufe ${amount} von ${symbol}`);
        // await exchange.createMarketSellOrder(symbol, amount); // Kommentiere aus für echten Handel
    } else {
        console.log('Keine Aktion');
    }
}

// Endlos-Schleife, die die Strategie alle 15 Minuten überprüft
const symbol = 'BTC/USDT';
const amount = 0.001;  // Menge des zu handelnden Assets

async function runBot() {
    while (true) {
        try {
            const signal = await movingAverageStrategy(symbol);
            await executeTrade(signal, symbol, amount);
        } catch (error) {
            console.error('Fehler beim Ausführen des Bots:', error);
        }
        await new Promise(resolve => setTimeout(resolve, 900000));  // 15 Minuten warten
    }
}

// Bot starten
runBot();

Hinweis: Bei diesem Bot wurde auf das Risk Management verzichtet, Du müsstest den Stop-Loss und Take-Profit noch programmieren, gemäß Deines individuellen Risikoprofils.

3. Klassiker: Mit MQL4 & MQL5 Trading Bots programmieren

MQL möchte ich hier natürlich definitiv erwähnt haben, besonders wenn Du Trading Bots auf MetaTrader-Plattformen programmieren und nutzen möchtest. Die Sprache MQL (MetaQuotes Language) ist die Hauptsprache für algorithmisches Trading auf dem MetaTrader.

Sie wird spezifisch für die Erstellung von Expert Advisors (EAs), Indikatoren und Scripten auf diesen Plattformen genutzt und ist deshalb sehr stark verbreitet bzw. vielen Tradern auch bekannt. Hierbei unterscheiden wir in MQL4 für MetaTrader 4 und MQL5 für MetaTrader 5.

MQL5 Trading Bot Beispiel:

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   // Berechne und zeichne SMA20 und SMA50
   IndicatorCreate(Symbol(), Period(), INDICATOR_MA, 20, PRICE_CLOSE, MODE_SMA, EMPTY_VALUE, true);
   IndicatorCreate(Symbol(), Period(), INDICATOR_MA, 50, PRICE_CLOSE, MODE_SMA, EMPTY_VALUE, true);
   
   return(INIT_SUCCEEDED);
  }

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   // Hier könnte man Ressourcen freigeben, falls nötig
  }

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
   // Hole den aktuellen Preis
   double price = Close[0];

   // Berechne den gleitenden Durchschnitt (SMA20 und SMA50)
   double sma20 = iMA(Symbol(), 0, 20, 0, MODE_SMA, PRICE_CLOSE, 0);
   double sma50 = iMA(Symbol(), 0, 50, 0, MODE_SMA, PRICE_CLOSE, 0);

   // Signalprüfung
   if (sma20 > sma50)  // Kaufsignal: SMA20 über SMA50
     {
      // Wenn wir keine offene Kaufposition haben, kaufen
      if (PositionsTotal() == 0)
        {
         Print("Kaufe 0.1 Lot von ", Symbol());
         trade.Buy(0.1, Symbol());
        }
     }
   else if (sma20 < sma50)  // Verkaufssignal: SMA20 unter SMA50
     {
      // Wenn wir eine offene Kaufposition haben, verkaufen
      if (PositionsTotal() > 0)
        {
         Print("Schließe Kaufposition und verkaufe");
         trade.Sell(0.1, Symbol());
        }
     }
  }

//+------------------------------------------------------------------+
//| Expert Advisor start function (for orders, trades, etc.)         |
//+------------------------------------------------------------------+
void CheckForTrade(double sma20, double sma50)
  {
   // Diese Funktion prüft, ob gehandelt werden soll
   // Hier könnte man auch komplexere Regeln einfügen
  }

//+------------------------------------------------------------------+

Achtung: In diesem Bot fehlt das Risikomanagement. Du solltest Stop-Loss und Take-Profit entsprechend Deinem eigenen Risikoprofil einfügen.

Mein Zusatztipp: Nutze Pine Script für Signal-Bots

Pine Script ist speziell für TradingView und hat nichts mit Python zu tun, obwohl es gewisse Ähnlichkeiten in der Struktur aufweist.

Diese Programmiersprache ist eher auf den spezifischen Anwendungsfall von Charts, Indikatoren und Strategien zugeschnitten. Ich nutze Sie unter anderem für meine automatisierten Trading Signale, die ich in TradingView erhalte.

Pine Script Signal-Bot Beispiel:

//@version=5
strategy("EMA Trendfolge mit SL und TP", overlay=true)

// Eingaben für Stop-Loss und Take-Profit
stop_loss_percent = input(1.0, title="Stop-Loss (%)", minval=0.1)
take_profit_percent = input(2.0, title="Take-Profit (%)", minval=0.1)

// EMA-Indikatoren (EMA20 und EMA50)
ema20 = ta.ema(close, 20)
ema50 = ta.ema(close, 50)

// Plot der EMAs auf dem Chart
plot(ema20, title="EMA 20", color=color.blue)
plot(ema50, title="EMA 50", color=color.red)

// Berechnung von Kauf- und Verkaufssignalen
long_condition = ta.crossover(ema20, ema50)  // Kaufsignal: EMA20 kreuzt über EMA50
short_condition = ta.crossunder(ema20, ema50)  // Verkaufssignal: EMA20 kreuzt unter EMA50

// Einstieg in eine Long-Position
if (long_condition)
    strategy.entry("Long", strategy.long)

// Stop-Loss und Take-Profit für die Long-Position setzen
if (strategy.position_size > 0)
    long_stop_loss = strategy.position_avg_price * (1 - stop_loss_percent / 100)
    long_take_profit = strategy.position_avg_price * (1 + take_profit_percent / 100)
    strategy.exit("Take Profit/Stop Loss", "Long", stop=long_stop_loss, limit=long_take_profit)

// Einstieg in eine Short-Position
if (short_condition)
    strategy.entry("Short", strategy.short)

// Stop-Loss und Take-Profit für die Short-Position setzen
if (strategy.position_size < 0)
    short_stop_loss = strategy.position_avg_price * (1 + stop_loss_percent / 100)
    short_take_profit = strategy.position_avg_price * (1 - take_profit_percent / 100)
    strategy.exit("Take Profit/Stop Loss", "Short", stop=short_stop_loss, limit=short_take_profit)

Ich weiß übrigens sehr gut, wie nervig es ist, stundenlang E-Books zu wälzen und YouTube Videos zu schauen, nur um endlich irgendwann handeln zu können, deshalb habe ich das TradeLab entwickelt.

Darin befinden sich Strategien wie „Turtle Surge“, „Silent Strike“ und „Pulse Chaser“, die ich selbst getestet und „modernisiert“ habe, um sie fit für die heutigen Märkte zu machen.

Ich erkläre Dir genau, wie Du Backtests richtig durchführst, und habe alles so optimiert, dass Du sofort loslegen kannst – inklusive automatisierter Signale in Pine Script für die Turtle Surge. Also einfach Signale bekommen, Trade inklusive Einstieg, Stop-Loss und Take-Profit ausführen.

Schau Dir die PDF zum Research kostenlos an >>

FAQ – Trading Bot programmieren