Automatización del trading: programa tu ventaja, quita la emoción

Las 3 de la mañana. Tu setup de sweep se dispara. Estás dormido.

Tu bot coloca la operación, pone el stop y apunta a 3R. Todo mientras sueñas.

Las 6 de la mañana. Te despiertas. Posición cerrada. +2,8R de beneficio. El café sabe mejor.

El problema humano en el trading

Has pasado 6 meses puliendo una estrategia. La has pasado por backtest. La has probado hacia delante. Tasa de acierto: 62 %. R medio: 2,3. Ventaja confirmada.

Empiezas a operarla en real. ¿El resultado?

La verdad incómoda: Tienes una estrategia rentable. Pero TÚ eres el eslabón débil.

Los tres asesinos de la ejecución

1. Dudar (saltarse operaciones por miedo)

• Acabas de encajar 2 pérdidas. Aparece el setup n.º 3. Piensas: «Quizá espere a confirmar…».
• Esperas. El precio se va sin ti. Era un ganador de 4R. Te lo perdiste por miedo.
• Efecto: Saltarte los ganadores destruye la esperanza positiva

2. Sobreoperar (entradas por FOMO)

• El mercado se dispara. Tu estrategia dice «no hay setup». Pero no soportas quedarte mirando. Entras igual.
• Sin stop. Sin plan. Solo esperanza. Se da la vuelta. Pierdes.
• Efecto: Las entradas aleatorias diluyen tu ventaja con ruido

3. Tamaño de posición inconsistente

• Setup A: arriesgas un 1 % (cauto tras la última pérdida)
• Setup B: arriesgas un 5 % (confiado, «lo estoy viendo claro»)
• El setup A gana 3R. Ganas un 3 %. El setup B pierde 1R. Pierdes un 5 %. Neto: -2 %.
• Efecto: Una sola mala decisión de tamaño se lleva por delante 3 buenas operaciones

El problema de escala (los límites del trading manual)

El trading manual limita tu potencial:

Ejemplo: Un trader manual vigila ES (futuros del S&P) en el gráfico de 15 minutos. Caza unos 8 setups por semana. Gana 3.200 $ al mes de media, unos 92 $ por setup.

El mismo trader, automatizado: El bot escanea ES, NQ y RTY (futuros de índices) más GC y CL (metales y energía) en 5m, 15m y 1h. Caza unos 24 setups por semana. A los mismos 92 $ por setup, eso son 9.600 $ al mes.

La palanca: No estás operando mejor. Estás operando MÁS, sin quemarte.

Y el techo: ES, MES, SPY y QQQ son en gran medida la misma operación. Añadir símbolos correlacionados multiplica tu recuento de señales sin multiplicar tu ventaja, y multiplica tu riesgo cuando cuatro se disparan a la vez. Cuenta oportunidades no correlacionadas, no tickers.

Cuándo tiene sentido automatizar (y cuándo no)

La automatización funciona mejor con:

• Estrategias basadas en reglas: Criterios claros de entrada y salida (p. ej., «comprar cuando el precio barre un mínimo y lo recupera»)
• Setups frecuentes: Estrategias que se disparan más de 10 veces por semana (el volumen justifica el tiempo de programación)
• Ejecución aburrida: Estrategias donde la discreción no aporta valor (ventajas mecánicas)

La automatización sufre con:

• Setups discrecionales: «Solo opero esto cuando *me lo pide el cuerpo*» (la intuición no se programa)
• Operaciones dependientes del contexto: «Esta ruptura funciona si el volumen supera 2 veces la media Y hay un catalizador de noticias» (el contexto complejo es difícil de cuantificar)
• Estrategias de baja frecuencia: Setups que se disparan 1-2 veces al mes (no compensa el esfuerzo de programarlos)

Comparativa de API de brókeres

No todos los brókeres admiten trading automatizado. Y los que lo hacen varían muchísimo en calidad, coste y funciones.

Las mejores API de brókeres para trading automatizado

Guía rápida de decisión

Elige Alpaca si: estás aprendiendo automatización (la API más fácil, simulado gratis, la mejor documentación). Elige Interactive Brokers si: necesitas opciones, futuros o mercados globales (todas las clases de activos, 0,005 $ por acción, nivel institucional). Elige Binance si: solo haces cripto (mercados sin horario, más de 600 pares, 0,1 % de comisión).

De la idea de trading al código ejecutable

Tienes una estrategia manual. ¿Cómo la traduces a código que un bot pueda ejecutar?

El marco de traducción de estrategias en 5 pasos

Paso 1: definir las condiciones de entrada (solo reglas explícitas)

El trader manual piensa: «Compro cuando el precio barre un mínimo y rebota al alza».

Eso es demasiado vago para un bot. Un bot necesita lógica precisa:

• ¿Qué es un «sweep»? → El mínimo de la vela actual cae al menos un 0,3 % por debajo del mínimo relevante anterior
• ¿Qué es «rebota al alza»? → El precio cierra de nuevo por encima de ese mínimo en 1-3 velas
• ¿Qué es un «mínimo relevante»? → El mínimo más bajo de las últimas 20 velas

Versión codificada:

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:  # barrido un 0,3 % por debajo
    if current_close > swing_low:     # recuperado
        ENTRY = True  # setup de sweep confirmado

Paso 2: definir las condiciones de salida (stop y objetivo)

El trader manual: «Pongo el stop por debajo del barrido y tomo beneficios con una relación riesgo-recompensa de 3:1».

Versión codificada:

entry_price = current_close
stop_loss = swing_low * 0.995  # justo bajo el barrido
stop_distance = entry_price - stop_loss
target = entry_price + (stop_distance * 3)  # objetivo de 3R

Paso 3: definir el tamaño de posición (gestión del riesgo)

El trader manual: «Arriesgo alrededor de un 2 % por operación».

Versión codificada:

account_equity = 100000  # cuenta 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  # acciones a comprar

# Ejemplo: entrada 520 $, stop 518 $, distancia 2 $
# Tamano de posicion = 2.000 $ / 2 $ = 1.000 acciones
# ...que son 520.000 $ de SPY en una cuenta de 100.000 $. Una regla
# del 2 % no dice nada del nocional: un stop estrecho compra apalancamiento.
max_notional = account_equity * 1.5   # tope duro: 1,5 veces el capital
position_size = min(position_size, max_notional / entry_price)
# Con tope: 288 acciones. El riesgo real es de 576 $, no de 2.000 $ -
# ese es el precio, y es justo el que te mantiene en el negocio.

Paso 4: definir la gestión de la operación (opcional)

¿Sales por partes? ¿Arrastras el stop? ¿Tomas beneficios parciales?

Ejemplo: «Tomo el 50 % de beneficio en 2R y dejo correr el resto hasta 3R».

if current_price >= entry_price + (stop_distance * 2):
    SELL_HALF = True  # cerrar el 50 % en 2R
    # Mover el stop a break-even para el 50 % restante

Paso 5: definir filtros (evitar setups malos)

¿Qué condiciones invalidan el setup?

• Filtro horario: Operar solo en las 2 primeras horas de sesión (9:30-11:30 ET)
• Filtro de volatilidad: Saltar operaciones cuando el VIX supere 30 (demasiado errático)
• Filtro de tendencia: Solo setups largos cuando el precio esté por encima de la EMA de 50 periodos

if VIX > 30:
    SKIP_TRADE = True  # mercado demasiado volatil

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

# Paso 1: condiciones de entrada
swing_low = min([bar.low for bar in last_20_bars])
if current_bar.low < swing_low * 0.997:  # barrido
    if current_bar.close > swing_low:     # recuperado

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

        # Paso 3: tamano de posicion
        risk_amount = account_equity * 0.02
        size = risk_amount / (entry - stop)

        # Paso 4: gestion de la operacion (50 % en 2R)
        profit_target_partial = entry + ((entry - stop) * 2)

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

Implementación completa del bot (estrategia de sweep y reversión)

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

# Configuracion
API_KEY = os.getenv('ALPACA_API_KEY')  # NUNCA lo escribas en el codigo!
API_SECRET = os.getenv('ALPACA_API_SECRET')
api = tradeapi.REST(API_KEY, API_SECRET, 'https://paper-api.alpaca.markets')

MAX_NOTIONAL_MULT = 1.5   # nunca mantener mas de 1,5 veces el capital
MAX_DAILY_LOSS = 0.03     # boton de parada: parar el dia al -3 %

def get_swing_low(bars, lookback=20):
    # Excluye la vela actual. Si la incluyes, el minimo relevante ES el minimo
    # actual, la prueba de barrido nunca se cumple y el bot no dispara jamas.
    lows = [bar.l for bar in bars[-(lookback + 1):-1]]
    return min(lows)

def check_sweep(current_price, current_low, swing_low):
    # Barrido = minimo actual < minimo relevante (0,3 %), luego lo recupera
    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 riesgo
    by_risk = risk_amount / (entry - stop)
    by_notional = (equity * MAX_NOTIONAL_MULT) / entry  # el control que Mike no puso
    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):
    # Preguntale al broker; no te fies de una variable local. Un bracket que se
    # ejecuto y cerro de noche no debe bloquear el setup de manana.
    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"✓ Orden: {size} acciones @ ${entry} | Stop: ${stop} | Objetivo: ${target}")
        return order
    except Exception as e:
        print(f"✗ Orden fallida: {e}")
        return None

def run_bot(symbol='SPY'):
    print(f"Bot iniciado. Vigilando {symbol} en busca de setups de sweep...")

    while True:
        try:
            if not api.get_clock().is_open:      # control 1: horario de mercado
                time.sleep(60)
                continue
            if kill_switch_tripped(api):         # control 2: limite de perdida diaria
                print("🛑 Limite de perdida diaria alcanzado. Me retiro.")
                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 detectado @ ${current_price}")
                entry = current_price
                stop = swing_low * 0.995
                target = entry + (entry - stop) * 3  # 3R
                size = calculate_position_size(api, entry, stop)   # control 3: tope de nocional
                if size > 0:
                    place_bracket_order(api, symbol, size, entry, stop, target)

            time.sleep(60)  # comprobar cada minuto
        except Exception as e:
            print(f"Error: {e}")
            time.sleep(60)

run_bot()  # ~75 lineas - y las tres que mas importan son los controles.

Qué hace esto: Se conecta a Alpaca, obtiene velas de 1 minuto de SPY, detecta reversiones tras barrido (el mínimo barre por debajo del mínimo relevante y luego lo recupera), calcula el tamaño con un 2 % de riesgo limitado por el nocional, coloca una orden bracket (entrada + stop + objetivo de 3R) y lo repite cada 60 segundos, pero solo mientras el mercado está abierto, solo cuando el bróker dice que no hay posición y nunca si el día acumula un -3 %. Disciplina perfecta, cero emoción y tres frenos.

Simulado ≠ real

Tu bot funciona a la perfección en simulado. Lo despliegas en real. Se cae. Rechazan órdenes. Te quedas perplejo.

Bienvenido a producción.

Errores habituales (y cómo gestionarlos)

Errores habituales: Tiempo de conexión agotado, orden rechazada, ejecuciones parciales, límites de peticiones, mercado cerrado. Soluciones: Lógica de reintento (3× con espera exponencial), comprobaciones previas (fondos, horario, precio), gestión de ejecuciones parciales, control de peticiones (200 por minuto), comprobación de horario (9:30-16 ET). Los bots profesionales gestionan los errores con elegancia.

Lógica de reintento (imprescindible)

import uuid

def place_order_with_retry(api, **order_params):
    """Reintentar el envio de la orden hasta 3 veces"""
    max_retries = 3

    # El mismo id en cada intento. Si la primera peticion si llego al broker y
    # solo se perdio la respuesta, el reintento se rechaza como duplicado en
    # lugar de duplicarte la posicion.
    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  # Exito!

        except Exception as e:
            if attempt < max_retries - 1:
                wait = 2 ** attempt  # 1s y luego 2s (espera exponencial)
                print(f"Orden fallida: {e}. Reintento en {wait}s...")
                time.sleep(wait)
            else:
                # Ultimo intento fallido
                print(f"Orden fallida tras {max_retries} intentos: {e}")
                # Enviar aviso (email, SMS)
                raise  # Relanzar la excepcion

Monitorización y avisos (crítico)

Tu bot corre en un VPS en la nube. Estás cenando. Se topa con un error.

¿Cómo te enteras?

Respuesta: Con avisos.

import smtplib
from email.mime.text import MIMEText

def send_alert(subject, message):
    """Enviar aviso por email"""
    msg = MIMEText(message)
    msg['Subject'] = subject
    msg['From'] = 'bot@yourbot.com'
    msg['To'] = 'you@gmail.com'

    # Envio por SMTP de Gmail - necesita una contrasena de aplicacion de
    # Gmail, no la de tu cuenta; la autenticacion basica se cerro 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)

# Uso
try:
    # Logica de trading
    pass
except Exception as e:
    send_alert(
        subject="🚨 Error del bot de trading",
        message=f"El bot se topo con un error: {e}"
    )
    raise

Ahora te enteras en minutos si algo se rompe.

Alojamiento: dónde ejecutar tu bot

La automatización no es ponerla y olvidarla

Despliegas tu bot. Opera un mes. Tasa de éxito: 65 %. Igual que en el backtest. Estás encantado.

Mes 2: la tasa de éxito cae al 48 %. Estás perplejo.

¿Qué pasó?

El régimen de mercado cambió. Tu estrategia funciona en mercados en tendencia. El mercado pasó a lateral. Tu bot siguió operando. Los resultados sufrieron.

Lista de mantenimiento mensual del bot

1. Métricas de rendimiento: ¿Tasa de acierto dentro de un 5 % del backtest? ¿R medio positivo? ¿Drawdown aceptable? ¿Slippage empeorado? 2. Registros de errores: Errores de conexión, órdenes rechazadas, casos límite. 3. Comprobación de régimen: ¿El mercado sigue favoreciendo la estrategia? VIX elevado → pausar. Volatilidad baja → las rupturas sufren.

Si has llegado hasta aquí, entiendes que automatizar no es magia: es ejecución disciplinada a escala. Programa tu ventaja. Prueba con rigor. Despliega con cautela. Vigila sin parar.

Lecciones relacionadas