Automatisation du trading : code ton avantage, retire l'émotion

3 h du matin. Ton setup de sweep se déclenche. Tu dors.

Ton bot passe le trade, place le stop, vise 3R. Pendant que tu rêves.

6 h du matin. Tu te réveilles. Position clôturée. +2,8R de gain. Le café a meilleur goût.

Le problème humain dans le trading

Tu as passé 6 mois à peaufiner une stratégie. Passée au backtest. Testée en avant. Taux de réussite : 62 %. R moyen : 2,3. Avantage confirmé.

Tu la trades en réel. Le résultat ?

La vérité brutale : Tu as une stratégie rentable. Mais c'est TOI le maillon faible.

Les trois tueurs d'exécution

1. L'hésitation (sauter des trades par peur)

• Tu viens d'encaisser 2 pertes. Le setup n° 3 apparaît. Tu te dis : « J'attends peut-être une confirmation… »
• Tu attends. Le prix part sans toi. C'était un gagnant à 4R. Tu l'as manqué par peur.
• Effet : Sauter les gagnants détruit l'espérance positive

2. Le surtrading (entrées de FOMO)

• Le marché s'envole. Ta stratégie dit « pas de setup ». Mais tu ne supportes pas de regarder. Tu entres quand même.
• Pas de stop. Pas de plan. Juste de l'espoir. Ça retourne. Tu perds.
• Effet : Les entrées aléatoires diluent ton avantage dans le bruit

3. Une taille de position incohérente

• Setup A : tu risques 1 % (prudent après la dernière perte)
• Setup B : tu risques 5 % (confiant, « je le sens »)
• Le setup A gagne 3R. Tu fais 3 %. Le setup B perd 1R. Tu perds 5 %. Net : -2 %.
• Effet : Une seule mauvaise décision de taille efface 3 bons trades

Le problème d'échelle (les limites du trading manuel)

Le trading manuel plafonne ton potentiel :

Exemple : Un trader manuel suit ES (futures S&P) en 15 minutes. Il attrape environ 8 setups par semaine. Il gagne 3 200 $ par mois en moyenne, soit environ 92 $ par setup.

Le même trader, automatisé : Le bot scanne ES, NQ et RTY (futures indiciels) plus GC et CL (métaux et énergie) en 5m, 15m et 1h. Il attrape environ 24 setups par semaine. Aux mêmes 92 $ par setup, cela fait 9 600 $ par mois.

Le déclic : Tu ne trades pas mieux. Tu trades PLUS — sans t'épuiser.

Et le plafond : ES, MES, SPY et QQQ sont largement le même trade. Ajouter des symboles corrélés multiplie ton nombre de signaux sans multiplier ton avantage — et cela multiplie ton risque quand quatre d'entre eux se déclenchent ensemble. Compte les occasions décorrélées, pas les tickers.

Quand l'automatisation a du sens (et quand elle n'en a pas)

L'automatisation fonctionne le mieux pour :

• Les stratégies à règles : Critères d'entrée et de sortie clairs (par ex. « acheter quand le prix balaie un plus bas puis le reprend »)
• Les setups fréquents : Les stratégies qui se déclenchent plus de 10 fois par semaine (le volume justifie le temps de codage)
• L'exécution ennuyeuse : Les stratégies où le discernement n'apporte rien (avantages mécaniques)

L'automatisation peine avec :

• Les setups discrétionnaires : « Je ne trade ça que quand je le *sens* » (l'intuition ne se code pas)
• Les trades dépendants du contexte : « Cette cassure marche si le volume dépasse 2 fois la moyenne ET qu'il y a un catalyseur d'actualité » (un contexte complexe est difficile à quantifier)
• Les stratégies à faible fréquence : Les setups qui se déclenchent 1-2 fois par mois (l'effort de codage ne vaut pas le coup)

Comparatif des API de courtiers

Tous les courtiers ne permettent pas le trading automatisé. Et ceux qui le permettent varient énormément en qualité, en coût et en fonctionnalités.

Les meilleures API de courtiers pour le trading automatisé

Guide de décision rapide

Choisis Alpaca si : tu apprends l'automatisation (l'API la plus simple, simulation gratuite, la meilleure doc). Choisis Interactive Brokers si : il te faut options, futures ou marchés mondiaux (toutes les classes d'actifs, 0,005 $ par action, niveau institutionnel). Choisis Binance si : tu ne fais que de la crypto (marchés en continu, plus de 600 paires, 0,1 % de frais).

De l'idée de trading au code exécutable

Tu as une stratégie manuelle. Comment la traduire en code qu'un bot peut exécuter ?

Le cadre de traduction d'une stratégie en 5 étapes

Étape 1 : définir les conditions d'entrée (règles explicites uniquement)

Le trader manuel pense : « J'achète quand le prix balaie un plus bas et rebondit. »

C'est bien trop vague pour un bot. Un bot a besoin d'une logique précise :

• Qu'est-ce qu'un « sweep » ? → Le plus bas de la bougie actuelle passe au moins 0,3 % sous le plus bas de swing précédent
• Que veut dire « rebondit » ? → Le prix clôture à nouveau au-dessus du plus bas de swing en 1 à 3 bougies
• Qu'est-ce qu'un « plus bas de swing » ? → Le plus bas des 20 dernières bougies

Version codée :

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:  # balaye 0,3 % en dessous
    if current_close > swing_low:     # repris
        ENTRY = True  # setup de sweep confirme

Étape 2 : définir les conditions de sortie (stop et objectif)

Le trader manuel : « Je place mon stop sous le balayage et je prends mes gains à un rapport de 3 pour 1. »

Version codée :

entry_price = current_close
stop_loss = swing_low * 0.995  # juste sous le balayage
stop_distance = entry_price - stop_loss
target = entry_price + (stop_distance * 3)  # objectif 3R

Étape 3 : définir la taille de position (gestion du risque)

Le trader manuel : « Je risque environ 2 % par trade. »

Version codée :

account_equity = 100000  # compte de 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  # actions a acheter

# Exemple : entree 520 $, stop 518 $, distance 2 $
# Taille de position = 2 000 $ / 2 $ = 1 000 actions
# ...soit 520 000 $ de SPY sur un compte de 100 000 $. Une regle de
# 2 % ne dit rien du notionnel : un stop serre achete du levier.
max_notional = account_equity * 1.5   # plafond dur : 1,5 fois les fonds propres
position_size = min(position_size, max_notional / entry_price)
# Plafonne : 288 actions. Le vrai risque tombe a 576 $ et non 2 000 $ -
# c'est le prix a payer, et c'est lui qui te garde dans le jeu.

Étape 4 : définir la gestion du trade (facultatif)

Tu sors par paliers ? Tu suis avec un stop ? Tu prends des gains partiels ?

Exemple : « Je prends 50 % à 2R et je laisse courir le reste jusqu'à 3R. »

if current_price >= entry_price + (stop_distance * 2):
    SELL_HALF = True  # solder 50 % a 2R
    # Remonter le stop au point mort pour les 50 % restants

Étape 5 : définir les filtres (empêcher les mauvais setups)

Quelles conditions invalident le setup ?

• Filtre horaire : Ne trader que pendant les 2 premières heures de séance (9h30-11h30 ET)
• Filtre de volatilité : Sauter les trades quand le VIX dépasse 30 (trop haché)
• Filtre de tendance : Setups longs uniquement quand le prix est au-dessus de l'EMA 50 périodes

if VIX > 30:
    SKIP_TRADE = True  # marche trop volatil

if current_time < "09:30" or current_time > "11:30":
    SKIP_TRADE = True  # hors de la fenetre de trading

# Etape 1 : conditions d'entree
swing_low = min([bar.low for bar in last_20_bars])
if current_bar.low < swing_low * 0.997:  # balayage
    if current_bar.close > swing_low:     # repris

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

        # Etape 3 : taille de position
        risk_amount = account_equity * 0.02
        size = risk_amount / (entry - stop)

        # Etape 4 : gestion du trade (50 % a 2R)
        profit_target_partial = entry + ((entry - stop) * 2)

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

Implémentation complète du bot (stratégie de sweep et retournement)

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

# Configuration
API_KEY = os.getenv('ALPACA_API_KEY')  # NE JAMAIS ecrire en dur !
API_SECRET = os.getenv('ALPACA_API_SECRET')
api = tradeapi.REST(API_KEY, API_SECRET, 'https://paper-api.alpaca.markets')

MAX_NOTIONAL_MULT = 1.5   # ne jamais detenir plus de 1,5 fois les fonds propres
MAX_DAILY_LOSS = 0.03     # bouton d'arret : on stoppe la journee a -3 %

def get_swing_low(bars, lookback=20):
    # Exclure la bougie en cours. Si on la garde, le plus bas de swing EST le
    # plus bas actuel, le test de balayage n'est jamais vrai, le bot ne part pas.
    lows = [bar.l for bar in bars[-(lookback + 1):-1]]
    return min(lows)

def check_sweep(current_price, current_low, swing_low):
    # Balayage = plus bas actuel < plus bas de swing (0,3 %), puis reprise
    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 % de risque
    by_risk = risk_amount / (entry - stop)
    by_notional = (equity * MAX_NOTIONAL_MULT) / entry  # le garde-fou oublie par Mike
    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):
    # Demande au courtier ; ne te fie pas a une variable locale. Un bracket
    # execute et cloture la nuit ne doit pas bloquer le setup de demain.
    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"✓ Ordre : {size} actions @ ${entry} | Stop : ${stop} | Objectif : ${target}")
        return order
    except Exception as e:
        print(f"✗ Ordre echoue : {e}")
        return None

def run_bot(symbol='SPY'):
    print(f"Bot demarre. Surveillance de {symbol} pour des setups de sweep...")

    while True:
        try:
            if not api.get_clock().is_open:      # garde-fou 1 : heures de marche
                time.sleep(60)
                continue
            if kill_switch_tripped(api):         # garde-fou 2 : perte quotidienne
                print("🛑 Limite de perte quotidienne atteinte. J'arrete.")
                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 detecte @ ${current_price}")
                entry = current_price
                stop = swing_low * 0.995
                target = entry + (entry - stop) * 3  # 3R
                size = calculate_position_size(api, entry, stop)   # garde-fou 3 : notionnel
                if size > 0:
                    place_bracket_order(api, symbol, size, entry, stop, target)

            time.sleep(60)  # verifier chaque minute
        except Exception as e:
            print(f"Erreur : {e}")
            time.sleep(60)

run_bot()  # ~75 lignes - et les trois qui comptent le plus sont les garde-fous.

Ce que ça fait : Se connecte à Alpaca, récupère les bougies 1 minute de SPY, détecte les retournements après balayage (le plus bas passe sous le plus bas de swing puis le reprend), calcule la taille sur 2 % de risque plafonnée par le notionnel, passe un ordre bracket (entrée + stop + objectif 3R) et recommence toutes les 60 secondes — mais seulement quand le marché est ouvert, seulement si le courtier dit qu'aucune position n'est ouverte, et jamais si la journée est à -3 %. Discipline parfaite, zéro émotion, et trois freins.

Simulation ≠ réel

Ton bot tourne parfaitement en simulation. Tu le passes en réel. Il plante. Des ordres sont rejetés. Tu ne comprends plus.

Bienvenue en production.

Erreurs courantes (et comment les gérer)

Erreurs courantes : Délai de connexion dépassé, ordre rejeté, exécutions partielles, limites de requêtes, marché fermé. Correctifs : Logique de réessai (3× avec attente exponentielle), vérifications préalables (fonds, horaires, prix), gestion des exécutions partielles, limitation des requêtes (200 par minute), vérification des horaires (9h30-16h ET). Les bots professionnels gèrent les erreurs proprement.

Logique de réessai (indispensable)

import uuid

def place_order_with_retry(api, **order_params):
    """Reessayer l'envoi de l'ordre jusqu'a 3 fois"""
    max_retries = 3

    # Le meme identifiant a chaque tentative. Si la premiere requete est bien
    # arrivee chez le courtier et que seule la reponse s'est perdue, le
    # reessai est rejete comme doublon au lieu de doubler ta position.
    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  # Succes !

        except Exception as e:
            if attempt < max_retries - 1:
                wait = 2 ** attempt  # 1s puis 2s (attente exponentielle)
                print(f"Ordre echoue : {e}. Nouvel essai dans {wait}s...")
                time.sleep(wait)
            else:
                # Derniere tentative echouee
                print(f"Ordre echoue apres {max_retries} tentatives : {e}")
                # Envoyer une alerte (e-mail, SMS)
                raise  # Relancer l'exception

Surveillance et alertes (critique)

Ton bot tourne sur un VPS dans le cloud. Tu es au restaurant. Il rencontre une erreur.

Comment le sais-tu ?

Réponse : Par des alertes.

import smtplib
from email.mime.text import MIMEText

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

    # Envoi via le SMTP Gmail - il faut un mot de passe d'application
    # Gmail, pas celui du compte ; l'auth basique a ete coupee en 2022.
    with smtplib.SMTP('smtp.gmail.com', 587) as server:
        server.starttls()
        server.login('bot@yourbot.com', os.getenv('EMAIL_PASSWORD'))
        server.send_message(msg)

# Utilisation
try:
    # Logique de trading
    pass
except Exception as e:
    send_alert(
        subject="🚨 Erreur du bot de trading",
        message=f"Le bot a rencontre une erreur : {e}"
    )
    raise

Tu sais maintenant en quelques minutes si quelque chose casse.

Hébergement : où faire tourner ton bot

L'automatisation n'est pas du « je pose et j'oublie »

Tu déploies ton bot. Il trade un mois. Taux de succès : 65 %. Comme au backtest. Tu es ravi.

Mois 2 : le taux de succès tombe à 48 %. Tu ne comprends pas.

Que s'est-il passé ?

Le régime de marché a changé. Ta stratégie marche en marché en tendance. Le marché est passé en range. Ton bot a continué à trader. Les résultats en ont souffert.

Check-list mensuelle d'entretien du bot

1. Indicateurs de performance : Taux de réussite à moins de 5 % du backtest ? R moyen positif ? Drawdown acceptable ? Slippage dégradé ? 2. Journaux d'erreurs : Erreurs de connexion, ordres rejetés, cas limites. 3. Vérification du régime : Le marché favorise-t-il encore la stratégie ? VIX élevé → mettre en pause. Faible volatilité → les cassures galèrent.

Si tu es arrivé jusqu'ici, tu comprends que l'automatisation n'a rien de magique : c'est de l'exécution disciplinée à grande échelle. Code ton avantage. Teste rigoureusement. Déploie prudemment. Surveille en continu.

Leçons associées