Automazione del trading: programma il tuo vantaggio, togli l'emozione

Le 3 di notte. Il tuo setup di sweep scatta. Tu dormi.

Il tuo bot piazza l'operazione, mette lo stop e punta a 3R. Mentre tu sogni.

Le 6 del mattino. Ti svegli. Posizione chiusa. +2,8R di profitto. Il caffè ha un altro sapore.

Il problema umano nel trading

Hai passato 6 mesi a perfezionare una strategia. L'hai messa in backtest. Testata in avanti. Win rate: 62 %. R medio: 2,3. Vantaggio confermato.

Cominci a operarla in reale. Il risultato?

La verità brutale: Hai una strategia profittevole. Ma l'anello debole sei TU.

I tre killer dell'esecuzione

1. Esitazione (saltare per paura)

• Hai appena incassato 2 perdite. Arriva il setup n. 3. Pensi: «Forse aspetto una conferma…».
• Aspetti. Il prezzo parte senza di te. Era un vincente da 4R. L'hai perso per paura.
• Effetto: Saltare i vincenti distrugge l'aspettativa positiva

2. Overtrading (ingressi da FOMO)

• Il mercato scappa al rialzo. La tua strategia dice «nessun setup». Ma non reggi a guardare. Entri lo stesso.
• Nessuno stop. Nessun piano. Solo speranza. Gira. Perdi.
• Effetto: Gli ingressi casuali diluiscono il tuo vantaggio nel rumore

3. Size di posizione incoerente

• Setup A: rischi l'1 % (prudente dopo l'ultima perdita)
• Setup B: rischi il 5 % (sicuro di te, «lo sento»)
• Il setup A guadagna 3R. Fai il 3 %. Il setup B perde 1R. Perdi il 5 %. Netto: -2 %.
• Effetto: Una sola decisione sbagliata sulla size cancella 3 buone operazioni

Il problema della scala (i limiti del trading manuale)

Il trading manuale mette un tetto al tuo potenziale:

Esempio: Un trader manuale segue ES (futures sull'S&P) sul grafico a 15 minuti. Prende circa 8 setup a settimana. Guadagna in media 3.200 $ al mese, circa 92 $ per setup.

Lo stesso trader, automatizzato: Il bot scansiona ES, NQ e RTY (futures sugli indici) più GC e CL (metalli ed energia) su 5m, 15m e 1h. Prende circa 24 setup a settimana. Agli stessi 92 $ per setup, fanno 9.600 $ al mese.

Lo sblocco: Non stai operando meglio. Stai operando DI PIÙ — senza bruciarti.

E il tetto: ES, MES, SPY e QQQ sono in larga parte la stessa operazione. Aggiungere simboli correlati moltiplica il numero di segnali senza moltiplicare il vantaggio — e moltiplica il rischio quando quattro scattano insieme. Conta le occasioni non correlate, non i ticker.

Quando l'automazione ha senso (e quando no)

L'automazione funziona meglio con:

• Strategie a regole: Criteri di ingresso e uscita chiari (es. «compra quando il prezzo spazza un minimo e poi lo riprende»)
• Setup frequenti: Strategie che scattano più di 10 volte a settimana (il volume giustifica il tempo di programmazione)
• Esecuzione noiosa: Strategie in cui la discrezionalità non aggiunge valore (vantaggi meccanici)

L'automazione fatica con:

• Setup discrezionali: «Lo opero solo quando *me lo sento*» (l'intuito non si programma)
• Operazioni legate al contesto: «Questo breakout funziona se il volume supera 2 volte la media E c'è un catalizzatore di notizie» (un contesto complesso è difficile da quantificare)
• Strategie a bassa frequenza: Setup che scattano 1-2 volte al mese (non vale lo sforzo di programmarli)

Confronto tra le API dei broker

Non tutti i broker supportano il trading automatizzato. E quelli che lo fanno cambiano moltissimo per qualità, costi e funzioni.

Le migliori API di broker per il trading automatizzato

Guida rapida alla scelta

Scegli Alpaca se: stai imparando l'automazione (l'API più semplice, paper trading gratuito, la documentazione migliore). Scegli Interactive Brokers se: ti servono opzioni, futures o mercati globali (tutte le classi di attivo, 0,005 $ per azione, livello istituzionale). Scegli Binance se: fai solo cripto (mercati senza orario, oltre 600 coppie, 0,1 % di commissioni).

Dall'idea di trading al codice eseguibile

Hai una strategia manuale. Come la traduci in codice che un bot possa eseguire?

Il framework in 5 passi per tradurre una strategia

Passo 1: definire le condizioni di ingresso (solo regole esplicite)

Il trader manuale pensa: «Compro quando il prezzo spazza un minimo e rimbalza».

Troppo vago per un bot. Un bot ha bisogno di logica precisa:

• Cos'è uno «sweep»? → Il minimo della candela attuale scende almeno lo 0,3 % sotto il minimo di swing precedente
• Cosa vuol dire «rimbalza»? → Il prezzo chiude di nuovo sopra il minimo di swing entro 1-3 candele
• Cos'è un «minimo di swing»? → Il minimo più basso delle ultime 20 candele

Versione in codice:

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:  # spazzato dello 0,3 % sotto
    if current_close > swing_low:     # ripreso
        ENTRY = True  # setup di sweep confermato

Passo 2: definire le condizioni di uscita (stop e obiettivo)

Il trader manuale: «Metto lo stop sotto lo sweep e prendo profitto a un rapporto rischio-rendimento di 3:1».

Versione in codice:

entry_price = current_close
stop_loss = swing_low * 0.995  # appena sotto lo sweep
stop_distance = entry_price - stop_loss
target = entry_price + (stop_distance * 3)  # obiettivo 3R

Passo 3: definire la size di posizione (gestione del rischio)

Il trader manuale: «Rischio circa il 2 % per operazione».

Versione in codice:

account_equity = 100000  # conto da 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  # azioni da comprare

# Esempio: ingresso 520 $, stop 518 $, distanza 2 $
# Size di posizione = 2.000 $ / 2 $ = 1.000 azioni
# ...cioe 520.000 $ di SPY su un conto da 100.000 $. Una regola del
# 2 % non dice nulla sul nozionale: uno stop stretto compra leva.
max_notional = account_equity * 1.5   # tetto rigido: 1,5 volte il capitale
position_size = min(position_size, max_notional / entry_price)
# Con il tetto: 288 azioni. Il rischio vero e 576 $, non 2.000 $ -
# questo e il prezzo da pagare, ed e cio che ti tiene in gioco.

Passo 4: definire la gestione dell'operazione (facoltativo)

Esci a scaglioni? Trascini lo stop? Prendi profitti parziali?

Esempio: «Prendo il 50 % di profitto a 2R e lascio correre il resto fino a 3R».

if current_price >= entry_price + (stop_distance * 2):
    SELL_HALF = True  # chiudere il 50 % a 2R
    # Spostare lo stop a pareggio per il restante 50 %

Passo 5: definire i filtri (evitare i setup cattivi)

Quali condizioni invalidano il setup?

• Filtro orario: Operare solo nelle prime 2 ore di seduta (9:30-11:30 ET)
• Filtro di volatilità: Saltare le operazioni quando il VIX supera 30 (troppo nervoso)
• Filtro di trend: Setup long solo quando il prezzo è sopra l'EMA a 50 periodi

if VIX > 30:
    SKIP_TRADE = True  # mercato troppo volatile

if current_time < "09:30" or current_time > "11:30":
    SKIP_TRADE = True  # fuori dalla finestra operativa

# Passo 1: condizioni di ingresso
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:     # ripreso

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

        # Passo 3: size di posizione
        risk_amount = account_equity * 0.02
        size = risk_amount / (entry - stop)

        # Passo 4: gestione dell'operazione (50 % a 2R)
        profit_target_partial = entry + ((entry - stop) * 2)

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

Implementazione completa del bot (strategia sweep e inversione)

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

# Configurazione
API_KEY = os.getenv('ALPACA_API_KEY')  # MAI scriverla nel codice!
API_SECRET = os.getenv('ALPACA_API_SECRET')
api = tradeapi.REST(API_KEY, API_SECRET, 'https://paper-api.alpaca.markets')

MAX_NOTIONAL_MULT = 1.5   # mai tenere piu di 1,5 volte il capitale
MAX_DAILY_LOSS = 0.03     # pulsante di arresto: si chiude la giornata a -3 %

def get_swing_low(bars, lookback=20):
    # Escludi la candela in corso. Se la includi, il minimo di swing E il
    # minimo attuale, il test di sweep non e mai vero e il bot non parte mai.
    lows = [bar.l for bar in bars[-(lookback + 1):-1]]
    return min(lows)

def check_sweep(current_price, current_low, swing_low):
    # Sweep = minimo attuale < minimo di swing (0,3 %), poi lo riprende
    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 % di rischio
    by_risk = risk_amount / (entry - stop)
    by_notional = (equity * MAX_NOTIONAL_MULT) / entry  # il controllo che Mike non aveva
    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):
    # Chiedi al broker; non fidarti di una variabile locale. Un bracket
    # eseguito e chiuso di notte non deve bloccare il setup di domani.
    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"✓ Ordine: {size} azioni @ ${entry} | Stop: ${stop} | Obiettivo: ${target}")
        return order
    except Exception as e:
        print(f"✗ Ordine fallito: {e}")
        return None

def run_bot(symbol='SPY'):
    print(f"Bot avviato. Sorveglio {symbol} in cerca di setup di sweep...")

    while True:
        try:
            if not api.get_clock().is_open:      # controllo 1: orari di mercato
                time.sleep(60)
                continue
            if kill_switch_tripped(api):         # controllo 2: perdita giornaliera
                print("🛑 Limite di perdita giornaliera raggiunto. Mi fermo.")
                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 rilevato @ ${current_price}")
                entry = current_price
                stop = swing_low * 0.995
                target = entry + (entry - stop) * 3  # 3R
                size = calculate_position_size(api, entry, stop)   # controllo 3: tetto nozionale
                if size > 0:
                    place_bracket_order(api, symbol, size, entry, stop, target)

            time.sleep(60)  # controlla ogni minuto
        except Exception as e:
            print(f"Errore: {e}")
            time.sleep(60)

run_bot()  # ~75 righe - e le tre che contano di piu sono i controlli.

Cosa fa: Si collega ad Alpaca, scarica le candele a 1 minuto di SPY, rileva le inversioni dopo lo sweep (il minimo spazza sotto il minimo di swing e poi lo riprende), calcola la size sul 2 % di rischio con tetto sul nozionale, piazza un ordine bracket (ingresso + stop + obiettivo 3R) e ripete ogni 60 secondi — ma solo a mercato aperto, solo quando il broker dice che non ci sono posizioni, e mai se la giornata è a -3 %. Disciplina perfetta, zero emozione e tre freni.

Paper trading ≠ trading reale

Il tuo bot funziona alla perfezione in paper trading. Lo metti in reale. Va in crash. Gli ordini vengono rifiutati. Non ci capisci più nulla.

Benvenuto in produzione.

Errori comuni (e come gestirli)

Errori comuni: Timeout di connessione, ordine rifiutato, esecuzioni parziali, limiti di richieste, mercato chiuso. Rimedi: Logica di riprova (3× con attesa esponenziale), controlli preventivi (fondi, orari, prezzo), gestione delle esecuzioni parziali, limitazione delle richieste (200 al minuto), controllo degli orari (9:30-16 ET). I bot professionali gestiscono gli errori con eleganza.

Logica di riprova (indispensabile)

import uuid

def place_order_with_retry(api, **order_params):
    """Riprova l'invio dell'ordine fino a 3 volte"""
    max_retries = 3

    # Lo stesso id a ogni tentativo. Se la prima richiesta e davvero arrivata
    # al broker e si e persa solo la risposta, la riprova viene rifiutata come
    # duplicato invece di raddoppiarti la posizione.
    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  # Fatto!

        except Exception as e:
            if attempt < max_retries - 1:
                wait = 2 ** attempt  # 1s poi 2s (attesa esponenziale)
                print(f"Ordine fallito: {e}. Riprovo tra {wait}s...")
                time.sleep(wait)
            else:
                # Ultimo tentativo fallito
                print(f"Ordine fallito dopo {max_retries} tentativi: {e}")
                # Invia un avviso (email, SMS)
                raise  # Rilancia l'eccezione

Monitoraggio e avvisi (critico)

Il tuo bot gira su un VPS nel cloud. Tu sei a cena. Incappa in un errore.

Come lo scopri?

Risposta: Con gli avvisi.

import smtplib
from email.mime.text import MIMEText

def send_alert(subject, message):
    """Invia un avviso via email"""
    msg = MIMEText(message)
    msg['Subject'] = subject
    msg['From'] = 'bot@yourbot.com'
    msg['To'] = 'you@gmail.com'

    # Invio via SMTP di Gmail - serve una password per le app di Gmail,
    # non quella dell'account; l'autenticazione base e stata chiusa nel 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)

# Utilizzo
try:
    # Logica di trading
    pass
except Exception as e:
    send_alert(
        subject="🚨 Errore del bot di trading",
        message=f"Il bot ha incontrato un errore: {e}"
    )
    raise

Adesso scopri in pochi minuti se qualcosa si rompe.

Hosting: dove far girare il bot

L'automazione non è «imposta e dimentica»

Metti in produzione il bot. Opera per un mese. Tasso di successo: 65 %. Come nel backtest. Sei entusiasta.

Mese 2: il tasso di successo scende al 48 %. Non capisci.

Cosa è successo?

Il regime di mercato è cambiato. La tua strategia funziona nei mercati in trend. Il mercato è passato in laterale. Il tuo bot ha continuato a operare. I risultati ne hanno risentito.

Checklist mensile di manutenzione del bot

1. Metriche di performance: Win rate entro il 5 % dal backtest? R medio positivo? Drawdown accettabile? Slippage peggiorato? 2. Registri degli errori: Errori di connessione, ordini rifiutati, casi limite. 3. Verifica del regime: Il mercato favorisce ancora la strategia? VIX elevato → mettere in pausa. Volatilità bassa → i breakout faticano.

Se sei arrivato fin qui, hai capito che automatizzare non è magia: è esecuzione disciplinata su larga scala. Programma il tuo vantaggio. Testa con rigore. Metti in produzione con prudenza. Monitora sempre.

Lezioni correlate