Handelsautomatisering: programmeer je edge, haal de emotie eruit

3 uur 's nachts. Je sweep-setup gaat af. Jij slaapt.

Je bot legt de trade in, zet de stop en mikt op 3R. Terwijl jij ligt te dromen.

6 uur 's ochtends. Je wordt wakker. Positie gesloten. +2,8R winst. De koffie smaakt beter.

Het menselijke probleem in trading

Je hebt 6 maanden aan een strategie geschaafd. Gebacktest. Vooruit getest. Winstpercentage: 62 %. Gemiddelde R: 2,3. Edge bevestigd.

Je gaat er live mee handelen. Het resultaat?

De harde waarheid: Je hebt een winstgevende strategie. Maar JIJ bent de zwakke schakel.

De drie uitvoeringsmoordenaars

1. Aarzelen (uit angst overslaan)

• Je hebt net 2 verliezen geslikt. Setup nr. 3 verschijnt. Je denkt: «Misschien wacht ik op bevestiging…»
• Je wacht. De koers loopt weg zonder jou. Het was een winnaar van 4R. Je miste hem uit angst.
• Gevolg: Winnaars overslaan vernietigt de positieve verwachting

2. Overhandelen (instappen uit FOMO)

• De markt schiet omhoog. Je strategie zegt «geen setup». Maar je kunt het niet aanzien. Je stapt toch in.
• Geen stop. Geen plan. Alleen hoop. Hij draait. Je verliest.
• Gevolg: Willekeurige entries verdunnen je edge met ruis

3. Inconsistente positiegrootte

• Setup A: je riskeert 1 % (voorzichtig na het laatste verlies)
• Setup B: je riskeert 5 % (zelfverzekerd, «ik voel hem»)
• Setup A wint 3R. Je maakt 3 %. Setup B verliest 1R. Je verliest 5 %. Netto: -2 %.
• Gevolg: Eén verkeerde beslissing over omvang wist 3 goede trades uit

Het schaalprobleem (de grenzen van handmatig handelen)

Handmatig handelen zet een dak op je potentieel:

Voorbeeld: Een handmatige trader volgt ES (S&P-futures) op de 15-minutengrafiek. Pakt zo'n 8 setups per week. Verdient gemiddeld $3.200 per maand, ongeveer $92 per setup.

Dezelfde trader, geautomatiseerd: De bot scant ES, NQ en RTY (indexfutures) plus GC en CL (metalen en energie) op 5m, 15m en 1u. Pakt zo'n 24 setups per week. Tegen dezelfde $92 per setup is dat $9.600 per maand.

De doorbraak: Je handelt niet beter. Je handelt MEER — zonder op te branden.

En het plafond: ES, MES, SPY en QQQ zijn grotendeels dezelfde trade. Gecorreleerde symbolen erbij zetten vermenigvuldigt je aantal signalen zonder je edge te vermenigvuldigen — en het vermenigvuldigt je risico als er vier tegelijk afgaan. Tel ongecorreleerde kansen, geen tickers.

Wanneer automatisering zin heeft (en wanneer niet)

Automatisering werkt het best bij:

• Regelgebaseerde strategieën: Heldere in- en uitstapcriteria (bijv. «koop als de koers een bodem wegveegt en die daarna herovert»)
• Frequente setups: Strategieën die meer dan 10 keer per week afgaan (het volume rechtvaardigt de codeertijd)
• Saaie uitvoering: Strategieën waar eigen oordeel niets toevoegt (mechanische edges)

Automatisering worstelt met:

• Discretionaire setups: «Ik handel dit alleen als het *goed voelt*» (intuïtie laat zich niet coderen)
• Contextafhankelijke trades: «Deze breakout werkt als het volume boven 2× het gemiddelde ligt ÉN er nieuws is» (complexe context is moeilijk te kwantificeren)
• Strategieën met lage frequentie: Setups die 1-2 keer per maand afgaan (het codeerwerk loont niet)

Vergelijking van broker-API's

Niet elke broker ondersteunt geautomatiseerd handelen. En die het wel doen, verschillen enorm in kwaliteit, kosten en mogelijkheden.

De beste broker-API's voor geautomatiseerd handelen

Snelle keuzehulp

Kies Alpaca als: je automatisering leert (de makkelijkste API, gratis papieren modus, de beste documentatie). Kies Interactive Brokers als: je opties, futures of wereldwijde markten nodig hebt (alle categorieën, $0,005 per aandeel, institutioneel niveau). Kies Binance als: het alleen om crypto gaat (markten zonder sluitingstijd, meer dan 600 paren, 0,1 % kosten).

Van handelsidee naar uitvoerbare code

Je hebt een handmatige strategie. Hoe vertaal je die naar code die een bot kan uitvoeren?

Het vertaalraamwerk in 5 stappen

Stap 1: entryvoorwaarden vastleggen (uitsluitend expliciete regels)

De handmatige trader denkt: «Ik koop als de koers een bodem wegveegt en terugveert.»

Dat is veel te vaag voor een bot. Een bot heeft precieze logica nodig:

• Wat is een «sweep»? → De low van de huidige candle duikt minstens 0,3 % onder de vorige swing low
• Wat is «terugveren»? → De koers sluit binnen 1-3 candles weer boven die swing low
• Wat is een «swing low»? → De laagste low van de afgelopen 20 candles

Gecodeerde versie:

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 % eronder weggeveegd
    if current_close > swing_low:     # heroverd
        ENTRY = True  # sweep-setup bevestigd

Stap 2: exitvoorwaarden vastleggen (stop en doel)

De handmatige trader: «Ik leg mijn stop onder de sweep en neem winst bij een verhouding van 3 op 1.»

Gecodeerde versie:

entry_price = current_close
stop_loss = swing_low * 0.995  # net onder de sweep
stop_distance = entry_price - stop_loss
target = entry_price + (stop_distance * 3)  # doel op 3R

Stap 3: positiegrootte vastleggen (risicobeheer)

De handmatige trader: «Ik riskeer ongeveer 2 % per trade.»

Gecodeerde versie:

account_equity = 100000  # rekening van $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  # te kopen aandelen

# Voorbeeld: entry $520, stop $518, afstand $2
# Positiegrootte = $2.000 / $2 = 1.000 aandelen
# ...oftewel $520.000 aan SPY op een rekening van $100.000. Een regel
# van 2 % zegt niets over de nominale waarde: een krappe stop koopt hefboom.
max_notional = account_equity * 1.5   # hard plafond: 1,5x het eigen vermogen
position_size = min(position_size, max_notional / entry_price)
# Met plafond: 288 aandelen. Het echte risico is nu $576, niet $2.000 -
# dat is de prijs, en juist die houdt je in het spel.

Stap 4: tradebeheer vastleggen (optioneel)

Bouw je af? Trek je de stop mee? Neem je deelwinst?

Voorbeeld: «Ik neem 50 % winst op 2R en laat de rest doorlopen naar 3R.»

if current_price >= entry_price + (stop_distance * 2):
    SELL_HALF = True  # 50 % afbouwen op 2R
    # Stop naar break-even voor de resterende 50 %

Stap 5: filters vastleggen (slechte setups voorkomen)

Welke omstandigheden maken de setup ongeldig?

• Tijdfilter: Alleen handelen in de eerste 2 beursuren (9:30-11:30 uur ET)
• Volatiliteitsfilter: Trades overslaan als de VIX boven 30 staat (te grillig)
• Trendfilter: Alleen long-setups als de koers boven de 50-perioden-EMA ligt

if VIX > 30:
    SKIP_TRADE = True  # markt te volatiel

if current_time < "09:30" or current_time > "11:30":
    SKIP_TRADE = True  # buiten het handelsvenster

# Stap 1: entryvoorwaarden
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:     # heroverd

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

        # Stap 3: positiegrootte
        risk_amount = account_equity * 0.02
        size = risk_amount / (entry - stop)

        # Stap 4: tradebeheer (50 % op 2R)
        profit_target_partial = entry + ((entry - stop) * 2)

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

Volledige implementatie van de bot (sweep-omkeerstrategie)

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

# Instellen
API_KEY = os.getenv('ALPACA_API_KEY')  # NOOIT hard in de code zetten!
API_SECRET = os.getenv('ALPACA_API_SECRET')
api = tradeapi.REST(API_KEY, API_SECRET, 'https://paper-api.alpaca.markets')

MAX_NOTIONAL_MULT = 1.5   # nooit meer dan 1,5x het eigen vermogen aanhouden
MAX_DAILY_LOSS = 0.03     # noodstop: bij -3 % stoppen we voor die dag

def get_swing_low(bars, lookback=20):
    # Sluit de huidige candle uit. Doe je dat niet, dan IS de swing low de
    # huidige low, wordt de sweep-test nooit waar en gaat de bot nooit af.
    lows = [bar.l for bar in bars[-(lookback + 1):-1]]
    return min(lows)

def check_sweep(current_price, current_low, swing_low):
    # Sweep = huidige low < swing low (0,3 %), daarna weer erboven
    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 % risico
    by_risk = risk_amount / (entry - stop)
    by_notional = (equity * MAX_NOTIONAL_MULT) / entry  # de controle die Mike miste
    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):
    # Vraag het de broker; vertrouw geen lokale variabele. Een bracket die 's
    # nachts is gevuld en gesloten mag de setup van morgen niet blokkeren.
    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} aandelen @ ${entry} | Stop: ${stop} | Doel: ${target}")
        return order
    except Exception as e:
        print(f"✗ Order mislukt: {e}")
        return None

def run_bot(symbol='SPY'):
    print(f"Bot gestart. Ik houd {symbol} in de gaten voor sweep-setups...")

    while True:
        try:
            if not api.get_clock().is_open:      # controle 1: beursuren
                time.sleep(60)
                continue
            if kill_switch_tripped(api):         # controle 2: daglimiet verlies
                print("🛑 Daglimiet voor verlies bereikt. Ik stop ermee.")
                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 gezien @ ${current_price}")
                entry = current_price
                stop = swing_low * 0.995
                target = entry + (entry - stop) * 3  # 3R
                size = calculate_position_size(api, entry, stop)   # controle 3: nominaal plafond
                if size > 0:
                    place_bracket_order(api, symbol, size, entry, stop, target)

            time.sleep(60)  # elke minuut kijken
        except Exception as e:
            print(f"Fout: {e}")
            time.sleep(60)

run_bot()  # ~75 regels - en de drie die er het meest toe doen zijn de controles.

Wat dit doet: Verbindt met Alpaca, haalt 1-minuutcandles van SPY op, herkent omkeringen na een sweep (de low veegt onder de swing low en herovert die daarna), bepaalt de omvang op 2 % risico begrensd door de nominale waarde, legt een bracketorder in (entry + stop + doel op 3R) en herhaalt dat elke 60 seconden — maar alleen zolang de beurs open is, alleen als de broker zegt dat er geen positie loopt, en nooit als de dag 3 % in de min staat. Perfecte discipline, nul emotie en drie remmen.

Papieren modus ≠ live handelen

Je bot draait perfect in papieren modus. Je zet hem live. Hij klapt eruit. Orders worden geweigerd. Je snapt er niets van.

Welkom in productie.

Veelvoorkomende fouten (en hoe je ze opvangt)

Veelvoorkomende fouten: Verbindingstime-out, geweigerde order, deelfills, verzoeklimieten, gesloten markt. Oplossingen: Herhaallogica (3× exponentieel wachten), controles vooraf (saldo, openingstijden, koers), afhandeling van deelfills, verzoekbegrenzing (200 per minuut), controle op beursuren (9:30-16 uur ET). Professionele bots vangen fouten netjes op.

Herhaallogica (onmisbaar)

import uuid

def place_order_with_retry(api, **order_params):
    """De order tot 3 keer opnieuw proberen te versturen"""
    max_retries = 3

    # Bij elke poging hetzelfde id. Als het eerste verzoek de broker wel
    # bereikte en alleen het antwoord verloren ging, wordt de herhaling als
    # duplicaat geweigerd in plaats van je positie te verdubbelen.
    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  # Gelukt!

        except Exception as e:
            if attempt < max_retries - 1:
                wait = 2 ** attempt  # 1s en daarna 2s (exponentieel wachten)
                print(f"Order mislukt: {e}. Nieuwe poging over {wait}s...")
                time.sleep(wait)
            else:
                # Laatste poging mislukt
                print(f"Order mislukt na {max_retries} pogingen: {e}")
                # Waarschuwing sturen (e-mail, sms)
                raise  # Uitzondering opnieuw opgooien

Monitoring en waarschuwingen (cruciaal)

Je bot draait op een VPS in de cloud. Jij zit te eten. Hij loopt tegen een fout aan.

Hoe weet je dat?

Antwoord: Met waarschuwingen.

import smtplib
from email.mime.text import MIMEText

def send_alert(subject, message):
    """Waarschuwing per e-mail versturen"""
    msg = MIMEText(message)
    msg['Subject'] = subject
    msg['From'] = 'bot@yourbot.com'
    msg['To'] = 'you@gmail.com'

    # Versturen via Gmail-SMTP - hiervoor is een Gmail-app-wachtwoord nodig,
    # niet je accountwachtwoord; basisauthenticatie ging in 2022 uit.
    with smtplib.SMTP('smtp.gmail.com', 587) as server:
        server.starttls()
        server.login('bot@yourbot.com', os.getenv('EMAIL_PASSWORD'))
        server.send_message(msg)

# Gebruik
try:
    # Handelslogica
    pass
except Exception as e:
    send_alert(
        subject="🚨 Fout in de handelsbot",
        message=f"De bot liep tegen een fout aan: {e}"
    )
    raise

Nu weet je binnen enkele minuten of er iets stukgaat.

Hosting: waar laat je je bot draaien

Automatisering is geen instellen-en-vergeten

Je zet je bot live. Hij handelt een maand. Slagingspercentage: 65 %. Precies als in de backtest. Je bent dolblij.

Maand 2: het slagingspercentage zakt naar 48 %. Je snapt er niets van.

Wat gebeurde er?

Het marktregime is veranderd. Je strategie werkt in trendende markten. De markt ging zijwaarts. Je bot bleef handelen. De resultaten leden eronder.

Maandelijkse onderhoudschecklist voor de bot

1. Prestatiecijfers: Winstpercentage binnen 5 % van de backtest? Gemiddelde R positief? Drawdown acceptabel? Slippage verslechterd? 2. Foutlogboeken: Verbindingsfouten, geweigerde orders, randgevallen. 3. Regimecheck: Is de markt nog gunstig voor de strategie? VIX hoog → pauzeren. Lage volatiliteit → breakouts hebben het zwaar.

Ben je zover gekomen, dan begrijp je dat automatisering geen magie is: het is gedisciplineerde uitvoering op schaal. Codeer je edge. Test grondig. Rol voorzichtig uit. Blijf volgen.

Gerelateerde lessen