Trading-Automatisierung: Programmiere deinen Vorteil, nimm die Emotion raus

3 Uhr nachts. Dein Sweep-Setup triggert. Du schläfst.

Dein Bot platziert den Trade, setzt den Stopp und zielt auf 3R. Und du träumst dabei.

6 Uhr morgens. Du wachst auf. Position geschlossen. +2,8R Gewinn. Der Kaffee schmeckt besser.

Das menschliche Problem im Trading

Du hast 6 Monate an einer Trading-Strategie gefeilt. Sie im backtest geprüft. Vorwärts getestet. Trefferquote: 62 %. Durchschnittliches R: 2,3. Der Vorteil ist bestätigt.

Du handelst sie live. Das Ergebnis?

Die brutale Wahrheit: Du hast eine profitable Strategie. Aber DU bist das schwache Glied.

Die drei Ausführungskiller

1. Zögern (Auslassen aus Angst)

• Du hast gerade 2 Verluste kassiert. Setup Nr. 3 erscheint. Du denkst: «Vielleicht warte ich auf Bestätigung …»
• Du wartest. Der Kurs läuft ohne dich. Es war ein 4R-Gewinner. Du hast ihn aus Angst verpasst.
• Auswirkung: Gewinner auszulassen zerstört den positiven Erwartungswert

2. Overtrading (FOMO-Einstiege)

• Der Markt zieht an. Deine Strategie sagt «kein Setup». Aber du hältst es nicht aus zuzuschauen. Du steigst trotzdem ein.
• Kein Stopp gesetzt. Kein Plan. Nur Hoffnung. Es dreht. Du verlierst.
• Auswirkung: Zufällige Einstiege verwässern deinen Vorteil mit Rauschen

3. Uneinheitliche Positionsgrößen

• Setup A: Du riskierst 1 % (vorsichtig nach dem letzten Verlust)
• Setup B: Du riskierst 5 % (selbstbewusst, «ich spüre es»)
• Setup A gewinnt 3R. Du machst 3 %. Setup B verliert 1R. Du verlierst 5 %. Netto: -2 %.
• Auswirkung: Eine einzige falsche Größenentscheidung frisst 3 gute Trades auf

Das Skalierungsproblem (Grenzen des manuellen Handels)

Manueller Handel deckelt dein Potenzial:

Beispiel: Ein manueller Trader beobachtet ES (S&P-Futures) im 15-Minuten-Chart. Erwischt rund 8 Setups pro Woche. Verdient im Schnitt 3.200 $ pro Monat — etwa 92 $ pro Setup.

Derselbe Trader, automatisiert: Der Bot scannt ES, NQ und RTY (Index-Futures) sowie GC und CL (Metalle und Energie) auf 5m, 15m und 1h. Erwischt rund 24 Setups pro Woche. Bei denselben 92 $ pro Setup sind das 9.600 $ pro Monat.

Der Hebel: Du handelst nicht besser. Du handelst MEHR — ohne auszubrennen.

Und die Obergrenze: ES, MES, SPY und QQQ sind weitgehend derselbe Trade. Korrelierte Symbole vervielfachen deine Signalzahl, nicht deinen Vorteil — und sie vervielfachen dein Risiko, wenn vier davon gleichzeitig auslösen. Zähle unkorrelierte Gelegenheiten, nicht Ticker.

Wann Automatisierung Sinn ergibt (und wann nicht)

Automatisierung funktioniert am besten bei:

• Regelbasierten Strategien: Klare Ein- und Ausstiegskriterien (z. B. «kaufe, wenn der Kurs ein Tief abfischt und es dann zurückerobert»)
• Häufigen Setups: Strategien, die mehr als 10-mal pro Woche auslösen (das Volumen rechtfertigt den Programmieraufwand)
• Langweiliger Ausführung: Strategien, bei denen Ermessen keinen Mehrwert bringt (mechanische Vorteile)

Automatisierung tut sich schwer mit:

• Diskretionären Setups: «Ich handle das nur, wenn es sich richtig *anfühlt*» (Intuition lässt sich nicht programmieren)
• Kontextabhängigen Trades: «Dieser Ausbruch funktioniert, wenn das Volumen über dem 2-fachen Durchschnitt liegt UND ein Nachrichtenkatalysator da ist» (komplexer Kontext ist schwer zu quantifizieren)
• Seltenen Strategien: Setups, die 1-2-mal pro Monat auslösen (der Programmieraufwand lohnt nicht)

Broker-API im Vergleich

Nicht jeder Broker unterstützt automatisierten Handel. Und die, die es tun, unterscheiden sich massiv in Qualität, Kosten und Funktionsumfang.

Die besten Broker-APIs für automatisierten Handel

Kurze Entscheidungshilfe

Wähle Alpaca, wenn: du Automatisierung lernst (einfachste API, kostenloses Paper Trading, beste Doku). Wähle Interactive Brokers, wenn: du Optionen/Futures/globale Märkte brauchst (alle Anlageklassen, 0,005 $ pro Aktie, institutionelles Niveau). Wähle Binance, wenn: es nur um Krypto geht (Märkte rund um die Uhr, über 600 Paare, 0,1 % Gebühren).

Von der Trading-Idee zum ausführbaren Code

Du hast eine manuelle Strategie. Wie übersetzt du sie in Code, den ein Bot ausführen kann?

Das 5-Schritte-Framework zur Strategieübersetzung

Schritt 1: Einstiegsbedingungen definieren (nur explizite Regeln)

Der manuelle Trader denkt: «Ich kaufe, wenn der Kurs ein Tief abfischt und wieder nach oben dreht.»

Das ist für einen Bot zu vage. Ein Bot braucht präzise Logik:

• Was ist ein «Sweep»? → Das Tief der aktuellen Kerze fällt mindestens 0,3 % unter das vorherige Swing-Tief
• Was heißt «dreht wieder nach oben»? → Der Kurs schließt innerhalb von 1-3 Kerzen wieder über dem Swing-Tief
• Was ist ein «Swing-Tief»? → Das tiefste Tief der letzten 20 Kerzen

Codierte Fassung:

swing_low = min([bar.low for bar in last_20_bars])
current_low = current_bar.low
current_close = current_bar.close

if current_low < swing_low * 0.997:  # 0,3 % darunter abgefischt
    if current_close > swing_low:     # zurueckerobert
        ENTRY = True  # Sweep-Setup bestaetigt

Schritt 2: Ausstiegsbedingungen definieren (Stopp und Ziel)

Der manuelle Trader: «Ich setze meinen Stopp unter den Sweep und nehme Gewinne bei einem Chance-Risiko-Verhältnis von 3:1.»

Codierte Fassung:

entry_price = current_close
stop_loss = swing_low * 0.995  # knapp unter dem Sweep
stop_distance = entry_price - stop_loss
target = entry_price + (stop_distance * 3)  # 3R-Ziel

Schritt 3: Positionsgröße definieren (Risikomanagement)

Der manuelle Trader: «Ich riskiere etwa 2 % pro Trade.»

Codierte Fassung:

account_equity = 100000  # Konto ueber 100.000 $
risk_per_trade = 0.02    # 2 %
risk_amount = account_equity * risk_per_trade  # 2.000 $

stop_distance = entry_price - stop_loss
position_size = risk_amount / stop_distance  # zu kaufende Aktien

# Beispiel: Einstieg 520 $, Stopp 518 $, Abstand 2 $
# Positionsgroesse = 2.000 $ / 2 $ = 1.000 Aktien
# ...das sind 520.000 $ SPY auf einem Konto ueber 100.000 $. 2 % Risiko
# sagen nichts ueber den Nominalwert: ein enger Stopp kauft dir Hebel.
max_notional = account_equity * 1.5   # harte Grenze: 1,5-faches Eigenkapital
position_size = min(position_size, max_notional / entry_price)
# Gedeckelt: 288 Aktien. Das echte Risiko liegt bei 576 $ statt 2.000 $ -
# das ist der Preis, und genau der haelt dich im Geschaeft.

Schritt 4: Trade-Management definieren (optional)

Skalierst du aus? Ziehst du Stopps nach? Nimmst du Teilgewinne mit?

Beispiel: «Ich nehme bei 2R 50 % Gewinn mit und lasse den Rest bis 3R laufen.»

if current_price >= entry_price + (stop_distance * 2):
    SELL_HALF = True  # bei 2R die Haelfte glattstellen
    # Stopp fuer die restlichen 50 % auf Einstand ziehen

Schritt 5: Filter definieren (schlechte Setups verhindern)

Welche Bedingungen entkräften das Setup?

• Zeitfilter: Nur in den ersten 2 Handelsstunden handeln (9:30-11:30 Uhr ET)
• Volatilitätsfilter: Trades auslassen, wenn der VIX über 30 liegt (zu unruhig)
• Trendfilter: Long-Setups nur, wenn der Kurs über der 50-Perioden-EMA liegt

if VIX > 30:
    SKIP_TRADE = True  # Markt zu volatil

if current_time < "09:30" or current_time > "11:30":
    SKIP_TRADE = True  # ausserhalb des Handelsfensters

# Schritt 1: Einstiegsbedingungen
swing_low = min([bar.low for bar in last_20_bars])
if current_bar.low < swing_low * 0.997:  # Sweep
    if current_bar.close > swing_low:     # zurueckerobert

        # Schritt 2: Ausstiege
        entry = current_bar.close
        stop = swing_low * 0.995
        target = entry + ((entry - stop) * 3)

        # Schritt 3: Positionsgroesse
        risk_amount = account_equity * 0.02
        size = risk_amount / (entry - stop)

        # Schritt 4: Trade-Management (bei 2R die Haelfte nehmen)
        profit_target_partial = entry + ((entry - stop) * 2)

        # Schritt 5: Filter
        if VIX < 30 and time_in_window():
            PLACE_ORDER(symbol, size, entry, stop, target)

Vollständige Bot-Umsetzung (Sweep-Reversal-Strategie)

import alpaca_trade_api as tradeapi
from alpaca_trade_api.rest import TimeFrame
import os, time

# Einrichtung
API_KEY = os.getenv('ALPACA_API_KEY')  # NIEMALS fest eincodieren!
API_SECRET = os.getenv('ALPACA_API_SECRET')
api = tradeapi.REST(API_KEY, API_SECRET, 'https://paper-api.alpaca.markets')

MAX_NOTIONAL_MULT = 1.5   # nie mehr als das 1,5-fache Eigenkapital halten
MAX_DAILY_LOSS = 0.03     # Not-Aus: bei -3 % fuer den Tag aussteigen

def get_swing_low(bars, lookback=20):
    # Die aktuelle Kerze ausschliessen. Nimmt man sie mit, IST das Swing-Tief
    # das aktuelle Tief, der Sweep-Test unten wird nie wahr, der Bot feuert nie.
    lows = [bar.l for bar in bars[-(lookback + 1):-1]]
    return min(lows)

def check_sweep(current_price, current_low, swing_low):
    # Sweep = aktuelles Tief < Swing-Tief (0,3 %), danach darueber zurueckerobert
    if current_low < swing_low * 0.997 and current_price > swing_low:
        return True
    return False

def calculate_position_size(api, entry, stop):
    equity = float(api.get_account().equity)
    risk_amount = equity * 0.02                        # 2 % Risiko
    by_risk = risk_amount / (entry - stop)
    by_notional = (equity * MAX_NOTIONAL_MULT) / entry  # die Kontrolle, die Mike fehlte
    return int(min(by_risk, by_notional))

def kill_switch_tripped(api):
    acct = api.get_account()
    move = (float(acct.equity) - float(acct.last_equity)) / float(acct.last_equity)
    return move <= -MAX_DAILY_LOSS

def in_position(api, symbol):
    # Frag den Broker; vertrau keiner lokalen Variable. Eine Bracket-Order, die
    # ueber Nacht ausgefuehrt und geschlossen wurde, darf morgen nichts blockieren.
    try:
        api.get_position(symbol)
        return True
    except Exception:
        return False

def place_bracket_order(api, symbol, size, entry, stop, target):
    try:
        order = api.submit_order(
            symbol=symbol, qty=size, side='buy', type='limit',
            limit_price=entry, time_in_force='gtc',
            order_class='bracket',
            stop_loss={'stop_price': stop},
            take_profit={'limit_price': target}
        )
        print(f"✓ Order: {size} Aktien @ ${entry} | Stopp: ${stop} | Ziel: ${target}")
        return order
    except Exception as e:
        print(f"✗ Order fehlgeschlagen: {e}")
        return None

def run_bot(symbol='SPY'):
    print(f"Bot gestartet. Beobachte {symbol} auf Sweep-Setups...")

    while True:
        try:
            if not api.get_clock().is_open:      # Kontrolle 1: Handelszeiten
                time.sleep(60)
                continue
            if kill_switch_tripped(api):         # Kontrolle 2: Tagesverlustgrenze
                print("🛑 Tagesverlustgrenze erreicht. Ich steige aus.")
                break

            bars = api.get_bars(symbol, TimeFrame.Minute, limit=50)
            current_price = bars[-1].c
            current_low = bars[-1].l
            swing_low = get_swing_low(bars)

            if not in_position(api, symbol) and check_sweep(current_price, current_low, swing_low):
                print(f"🎯 Sweep erkannt @ ${current_price}")
                entry = current_price
                stop = swing_low * 0.995
                target = entry + (entry - stop) * 3  # 3R
                size = calculate_position_size(api, entry, stop)   # Kontrolle 3: Nominalwert-Deckel
                if size > 0:
                    place_bracket_order(api, symbol, size, entry, stop, target)

            time.sleep(60)  # jede Minute pruefen
        except Exception as e:
            print(f"Fehler: {e}")
            time.sleep(60)

run_bot()  # ~75 Zeilen - und die drei wichtigsten davon sind die Kontrollen.

Was das macht: Verbindet sich mit Alpaca, holt 1-Minuten-Kerzen von SPY, erkennt Sweep-Reversals (das Tief fischt unter das Swing-Tief und erobert es zurück), bestimmt die Größe über 2 % Risiko gedeckelt durch den Nominalwert, platziert eine Bracket-Order (Einstieg + Stopp + 3R-Ziel) und wiederholt das alle 60 Sekunden — aber nur, solange der Markt offen ist, nur wenn der Broker meldet, dass keine Position offen ist, und nie, wenn der Tag 3 % im Minus liegt. Perfekte Disziplin, null Emotion und drei Bremsen.

Paper Trading ≠ Live-Trading

Dein Bot läuft im Paper Trading perfekt. Du rollst ihn live aus. Er stürzt ab. Orders werden abgelehnt. Du bist ratlos.

Willkommen im Produktivbetrieb.

Häufige Fehler (und wie man sie abfängt)

Häufige Fehler: Verbindungs-Timeout, abgelehnte Order, Teilausführungen, Rate Limits, geschlossener Markt. Lösungen: Wiederholungslogik (3× exponentielles Backoff), Vorabprüfungen (Guthaben, Handelszeiten, Kurs), Umgang mit Teilausführungen, Rate Limiting (200 Anfragen/Min.), Prüfung der Handelszeiten (9:30-16 Uhr ET). Professionelle Bots fangen Fehler sauber ab.

Wiederholungslogik (unverzichtbar)

import uuid

def place_order_with_retry(api, **order_params):
    """Orderplatzierung bis zu 3-mal wiederholen"""
    max_retries = 3

    # Bei jedem Versuch dieselbe ID. Kam die erste Anfrage tatsaechlich beim
    # Broker an und ging nur die Antwort verloren, wird die Wiederholung als
    # Duplikat abgelehnt, statt deine Position zu verdoppeln.
    order_params.setdefault('client_order_id', f"bot-{uuid.uuid4()}")

    for attempt in range(max_retries):
        try:
            order = api.submit_order(**order_params)
            return order  # Erfolg!

        except Exception as e:
            if attempt < max_retries - 1:
                wait = 2 ** attempt  # 1s, dann 2s (exponentielles Backoff)
                print(f"Order fehlgeschlagen: {e}. Wiederholung in {wait}s...")
                time.sleep(wait)
            else:
                # Letzter Versuch gescheitert
                print(f"Order nach {max_retries} Versuchen fehlgeschlagen: {e}")
                # Alarm senden (E-Mail, SMS)
                raise  # Ausnahme erneut werfen

Monitoring & Alarme (entscheidend)

Dein Bot läuft auf einem VPS in der Cloud. Du sitzt beim Abendessen. Er läuft in einen Fehler.

Woher weißt du das?

Antwort: Alarme.

import smtplib
from email.mime.text import MIMEText

def send_alert(subject, message):
    """E-Mail-Alarm senden"""
    msg = MIMEText(message)
    msg['Subject'] = subject
    msg['From'] = 'bot@yourbot.com'
    msg['To'] = 'you@gmail.com'

    # Versand ueber Gmail-SMTP - dafuer braucht es ein Gmail-App-Passwort,
    # nicht dein Kontopasswort; Basic Auth wurde 2022 abgeschaltet.
    with smtplib.SMTP('smtp.gmail.com', 587) as server:
        server.starttls()
        server.login('bot@yourbot.com', os.getenv('EMAIL_PASSWORD'))
        server.send_message(msg)

# Verwendung
try:
    # Trading-Logik
    pass
except Exception as e:
    send_alert(
        subject="🚨 Fehler im Trading-Bot",
        message=f"Der Bot lief in einen Fehler: {e}"
    )
    raise

Jetzt weißt du innerhalb von Minuten, wenn etwas kaputtgeht.

Hosting: Wo du deinen Bot laufen lässt

Automatisierung ist kein Selbstläufer

Du rollst deinen Bot aus. Er handelt einen Monat. Trefferquote: 65 %. Genau wie im backtest. Du bist begeistert.

Monat 2: Die Trefferquote fällt auf 48 %. Du bist ratlos.

Was geschah?

Das Marktregime hat sich geändert. Deine Strategie funktioniert in trendenden Märkten. Der Markt wechselte in eine Seitwärtsphase. Dein Bot handelte weiter. Die Ergebnisse litten.

Monatliche Wartungscheckliste für den Bot

1. Leistungskennzahlen: Trefferquote innerhalb von 5 % zum backtest? Durchschnittliches R positiv? Drawdown akzeptabel? Slippage verschlechtert? 2. Fehlerprotokolle: Verbindungsfehler, abgelehnte Orders, Sonderfälle. 3. Regimeprüfung: Begünstigt der Markt die Strategie noch? VIX erhöht → pausieren. Niedrige Volatilität → Ausbrüche tun sich schwer.

Wenn du bis hierher gekommen bist, verstehst du: Automatisierung ist keine Magie, sondern disziplinierte Ausführung in großem Maßstab. Programmiere deinen Vorteil. Teste gründlich. Rolle vorsichtig aus. Überwache fortlaufend.

Verwandte Lektionen