Het verschil tussen systeemrisico en marktrisico
Je staat te popelen om je Python-algoritmische bot live te zetten. Je hebt uren gesleuteld aan je backtest op een broker als Interactive Brokers of Bybit, je API-tokens zijn veilig en je risicomanagement script lijkt waterdicht.
Toch is er één stemmetje in je hoofd dat vraagt: wat als de hele markt implodeert? Dat gevoel, beste trader, is het hart van het verschil tussen systeemrisico en marktrisico. Dit onderscheid maken is het geheime wapen van traders die niet alleen overleven, maar floreren.
Wat is marktrisico?
Marktrisico is de rauwe, ongefilterde prijsactie van de markt zelf. Het is het risico dat je posities verliezen lijden puur omdat de prijs tegen je beweegt.
Denk aan een onverwachte renteverhoging van de ECB die de EUR/USD in vrije val doet slaan, of een plotseling negatief nieuwsbericht over Tesla dat de koers met 8% laat kelderen voor je stop-loss kan worden uitgevoerd. Dit is het risico dat je als trader actief probeert te managen met technische analyse, stop-losses en positiegroottes.
Stel je voor dat je een long positie op Bitcoin hebt geopend op $62.000. Je bot heeft een strakke stop-loss op $60.500. Als de prijs vanuit het niets naar $59.000 schiet en je positie wordt gesloten op een gemiddelde van $60.450 (slippage), dan heb je marktrisico gerealiseerd. Je strategie was misschien perfect, de markt was het er alleen niet mee eens. Dit risico is inherent aan het handelen in financiële activa en is de reden waarom we spreken van 'risk-on' en 'risk-off' omgevingen.
Wat is systeemrisico?
Systeemrisico is een heel ander beest. Dit is het risico dat je handelssysteem, je broker of je technische infrastructuur faalt, volledig los van wat de markt doet.
Het is het risico dat je bot niet doet wat hij moet doen, of dat de verbinding met de markt wordt verbroken op het meest ongunstige moment. Dit is het gevaar dat je verliezen niet beperkt blijft tot je 'risk-per-trade' van 1% van je account, maar kan oplopen tot een catastrofale 50% of meer door een technische glitch.
Denk aan een Python-script dat een 'KeyError' krijgt omdat de API van je broker (bijvoorbeeld Kraken of Binance) opeens een veld aanpast in hun JSON-response. Je bot crasht en kan niet meer handelen. Of erger: een infinite loop die in een fractie van een seconde honderden orders plaatst, waardoor je account wordt geblokkeerd of je tegen je eigen liquiditeit handelt. Dit is systeemrisico. De markt kan rustig zijn, maar jouw systeem ligt op zijn gat.
Het onderscheid: de kern van het probleem
De makkelijkste manier om het verschil te onthouden is dit: marktrisico is wat de markt *jou* aandoet; systeemrisico is wat *jij* (of je code) jezelf aandoet. Marktrisico is onvermijdelijk; je kunt niet handelen zonder het te accepteren.
Systeemrisico is theoretisch volledig te elimineren met de juiste code, testing en procedures.
De realiteit is dat je het nooit 100% kunt wegnemen, maar je kunt het wel minimaliseren tot een verwaarloosbaar niveau. Een concreet voorbeeld: je backtest op een platform als QuantConnect of een eigen Python-omgeving met Pandas en Backtrader laat een winstgevende strategie zien met een drawdown van 15%. Je zet hem live en na een week heb je 25% verlies. De oorzaak?
Marktrisico zou kunnen zijn dat de marktomstandigheden zijn veranderd (regime change). Systeemrisico is dat je backtest niet rekening hield met de werkelijke 'slippage' en 'commissies' van je broker, of dat je data-feed een hapering had waardoor je bot verkeerde beslissingen nam. Als je een verlies ziet, moet je weten welke container je het moet toewijzen. Als het marktrisico is, pas je je strategie aan of verlaag je je positiegrootte.
Waarom dit onderscheid cruciaal is voor je bot
Als het systeemrisico is, stop je onmiddellijk met traden en ga je debuggen.
Door ze te verwarren, ga je aan je strategie sleutelen die misschien wel perfect is, of juist niet aan je systeem werken waardoor je kwetsbaar blijft.
Modellen en bronnen van systeemrisico
Om systeemrisico te bestrijden, moeten we het opdelen in specifieke scenario's. In de wereld van algoritmische trading is een goed risicomanagement voor algoritmische traders essentieel, waarbij we kijken naar de volgende drie hoofdpijlers:
- API- en Broker Risico: De verbinding tussen jouw Python-script en de exchange. Denk aan 'rate limits' (bijv. 1200 requests per minuut op Binance), downtime van de API, of het plotseling aanpassen van endpoints. Een broker die failliet gaat (zoals FTX) is het ultieme systeemrisico.
- Code en Data Risico: Bugs in je logica. Een 'off-by-one error' in je Pandas DataFrame shift die ervoor zorgt dat je signalen verkeerd worden geïnterpreteerd. Of 'look-ahead bias' in je backtest data, waardoor je resultaten te mooi zijn om waar te zijn. Ook 'bad data' van een provider zoals CoinAPI of een exchange kan je bot direct op het verkeerde pad brengen.
- Infrastructuur Risico: Jijzelf. Je internetverbinding valt uit tijdens een cruciale trade. Je VPS (Virtual Private Server) bij DigitalOcean of AWS crasht. Je laptop gaat in slaapstand en je Python script stopt. Of erger: je vergeet een 'kill-switch' te activeren na een update.
Marktrisico modellen: De getallen die je kent
Marktrisico wordt vaak uitgedrukt in meetbare eenheden die je in je risicomanagement scripts verwerkt.
We gebruiken concepten als Value at Risk (VaR). Een VaR van €1.000 op 95% betekent dat je met 95% zekerheid niet meer dan €1.000 verliest op een dag. Of de Grieken bij opties (Delta, Gamma, Theta), hoewel die voor pure spot-algo traders minder relevant zijn.
Bij crypto focussen we op volatiliteit-maatregelen zoals de ATR (Average True Range). Stel, je backtest laat zien dat de gemiddelde dagelijkse beweging (ATR) van ETH €150 is. Je positie grootte is zo berekend dat een stop-loss van 2x ATR (€300) je account niet meer dan 2% pijn doet. Dat is het managen van marktrisico. Als je bot echter door een bug de stop-loss op een verkeerde prijs plaatst, of deze niet uitvoert, dan is het systeemrisico dat je marktrisico onbeheersbaar maakt.
Praktische tips: Je bot future-proof maken
Het bouwen van een robuust algoritmisch trading systeem draait om het verkleinen van systeemrisico zodat je je kunt concentreren op het navigeren van marktrisico.
- Implementeer een Kill-Switch: Zorg voor een apart script of een API-functie die bij je broker alle open posities onmiddellijk sluit (OCO orders of 'cancel all') als er iets misgaat. Test dit wekelijks. Je wilt niet debuggen terwijl je account leegloopt.
- Gebruik een Testnet: Voordat je ook maar één echte euro inzet, trade je wekenlang op de testnet van je broker (bijv. Binance Testnet of IBKR Paper Trading). Dit onthult systeemrisico's in je code zonder dat het je geld kost.
- Log alles: Gebruik Python's
loggingmodule naar een extern bestand of database. Log elke order, elke error en elke prijs die je binnenkrijgt. Als je bot crasht, weet je dankzij de logs precies waarom. - Hardcode geen API-keys: Gebruik environment variables (via
python-dotenv) om je keys op te slaan. Dit voorkomt dat je per ongeluk je keys publiceert op GitHub en je account wordt leeggehaald. - Monitor je 'Jitter': Houd bij hoeveel vertraging (latency) er zit tussen je signaal en de orderexecutie. Als je broker traag is, moet je je marktrisico (bijv. stop-loss afstanden) vergroten om slippage op te vangen.
De samensmelting: Waar systeem en markt elkaar raken
Hier is een concrete checklist die je direct kunt toepassen: voer de dagelijkse risico-check uit voor je actieve bots. Uiteindelijk wil je een systeem bouwen dat zo betrouwbaar is dat je vergeet dat het bestaat, zodat je je volledig kunt richten op het begrijpen van de markt. Denk aan de professionals die QuantConnect of hun eigen stack op AWS draaien. Ze weten dat hun systeemrisico op <1% ligt.
Daardoor kunnen ze agressief inspelen op marktrisico met hefboomproducten of complexe optiestrategieën. Als je net begint, focus dan eerst op systeemrisico.
Je eerste doel is niet om 10% per maand te verdienen, maar om te voorkomen dat je je inleg verliest door een stomme bug.
Zodra je systeem stabiel draait, en je weet het verschil tussen een verlies door slechte marktvoorspelling en een verlies door een API-tijdout, ben je pas een echte algoritmische trader.