Automação do trading: programe sua vantagem, tire a emoção

3 da manhã. Seu setup de sweep dispara. Você está dormindo.

Seu bot manda a ordem, coloca o stop e mira 3R. Tudo enquanto você sonha.

6 da manhã. Você acorda. Posição encerrada. +2,8R de lucro. O café tem outro sabor.

O problema humano no trading

Você passou 6 meses lapidando uma estratégia. Fez backtest. Testou para a frente. Taxa de acerto: 62 %. R médio: 2,3. Vantagem confirmada.

Você começa a operá-la de verdade. O resultado?

A verdade dura: Você tem uma estratégia lucrativa. Mas VOCÊ é o elo fraco.

Os três assassinos da execução

1. Hesitação (pular por medo)

• Você acabou de levar 2 perdas. Aparece o setup nº 3. Você pensa: «Talvez eu espere uma confirmação…».
• Você espera. O preço vai embora sem você. Era um vencedor de 4R. Você perdeu por medo.
• Efeito: Pular os vencedores destrói a expectativa positiva

2. Operar demais (entradas por FOMO)

• O mercado dispara. Sua estratégia diz «não tem setup». Mas você não aguenta só olhar. Entra assim mesmo.
• Sem stop. Sem plano. Só esperança. Ele vira. Você perde.
• Efeito: Entradas aleatórias diluem sua vantagem no ruído

3. Tamanho de posição inconsistente

• Setup A: você arrisca 1 % (cauteloso depois da última perda)
• Setup B: você arrisca 5 % (confiante, «estou sentindo»)
• O setup A ganha 3R. Você faz 3 %. O setup B perde 1R. Você perde 5 %. Líquido: -2 %.
• Efeito: Uma única decisão errada de tamanho apaga 3 boas operações

O problema de escala (os limites do trading manual)

O trading manual limita seu potencial:

Exemplo: Um trader manual acompanha o ES (futuro do S&P) no gráfico de 15 minutos. Pega uns 8 setups por semana. Ganha 3.200 $ por mês em média, cerca de 92 $ por setup.

O mesmo trader, automatizado: O bot escaneia ES, NQ e RTY (futuros de índice) mais GC e CL (metais e energia) em 5m, 15m e 1h. Pega uns 24 setups por semana. Aos mesmos 92 $ por setup, dá 9.600 $ por mês.

O destravamento: Você não está operando melhor. Está operando MAIS — sem se esgotar.

E o teto: ES, MES, SPY e QQQ são em grande parte a mesma operação. Somar símbolos correlacionados multiplica sua contagem de sinais sem multiplicar sua vantagem — e multiplica seu risco quando quatro disparam juntos. Conte oportunidades não correlacionadas, não tickers.

Quando a automação faz sentido (e quando não faz)

A automação funciona melhor com:

• Estratégias baseadas em regras: Critérios claros de entrada e saída (ex.: «comprar quando o preço varre um fundo e o recupera»)
• Setups frequentes: Estratégias que disparam mais de 10 vezes por semana (o volume justifica o tempo de programação)
• Execução chata: Estratégias em que o discricionário não agrega valor (vantagens mecânicas)

A automação sofre com:

• Setups discricionários: «Só opero isso quando *sinto* que é a hora» (intuição não se programa)
• Operações dependentes de contexto: «Esse rompimento funciona se o volume passar de 2 vezes a média E houver um catalisador de notícia» (contexto complexo é difícil de quantificar)
• Estratégias de baixa frequência: Setups que disparam 1-2 vezes por mês (não compensa o esforço de programar)

Comparativo de API de corretoras

Nem toda corretora aceita trading automatizado. E as que aceitam variam muito em qualidade, custo e recursos.

As melhores API de corretoras para trading automatizado

Guia rápido de decisão

Escolha a Alpaca se: você está aprendendo automação (a API mais fácil, simulador grátis, a melhor documentação). Escolha a Interactive Brokers se: você precisa de opções, futuros ou mercados globais (todas as classes de ativos, 0,005 $ por ação, nível institucional). Escolha a Binance se: for só cripto (mercados sem horário, mais de 600 pares, 0,1 % de taxa).

Da ideia de trading ao código executável

Você tem uma estratégia manual. Como traduzi-la em código que um bot execute?

O framework de tradução de estratégia em 5 passos

Passo 1: definir as condições de entrada (só regras explícitas)

O trader manual pensa: «Compro quando o preço varre um fundo e volta para cima».

Isso é vago demais para um bot. Um bot precisa de lógica precisa:

• O que é um «sweep»? → A mínima do candle atual cai pelo menos 0,3 % abaixo do fundo relevante anterior
• O que é «volta para cima»? → O preço fecha de novo acima desse fundo em 1-3 candles
• O que é um «fundo relevante»? → A menor mínima dos últimos 20 candles

Versão em código:

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:  # varreu 0,3 % abaixo
    if current_close > swing_low:     # recuperou
        ENTRY = True  # setup de sweep confirmado

Passo 2: definir as condições de saída (stop e alvo)

O trader manual: «Coloco o stop abaixo da varredura e realizo lucro numa relação risco-retorno de 3:1».

Versão em código:

entry_price = current_close
stop_loss = swing_low * 0.995  # logo abaixo da varredura
stop_distance = entry_price - stop_loss
target = entry_price + (stop_distance * 3)  # alvo de 3R

Passo 3: definir o tamanho de posição (gestão de risco)

O trader manual: «Arrisco cerca de 2 % por operação».

Versão em código:

account_equity = 100000  # conta 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  # acoes a comprar

# Exemplo: entrada 520 $, stop 518 $, distancia 2 $
# Tamanho da posicao = 2.000 $ / 2 $ = 1.000 acoes
# ...que sao 520.000 $ de SPY numa conta de 100.000 $. Uma regra de
# 2 % nao diz nada sobre o nocional: um stop curto compra alavancagem.
max_notional = account_equity * 1.5   # teto rigido: 1,5 vez o capital
position_size = min(position_size, max_notional / entry_price)
# Com teto: 288 acoes. O risco real cai para 576 $, e nao 2.000 $ -
# esse e o preco a pagar, e e justamente o que te mantem no jogo.

Passo 4: definir a gestão da operação (opcional)

Você sai em partes? Arrasta o stop? Realiza parciais?

Exemplo: «Realizo 50 % em 2R e deixo o resto correr até 3R».

if current_price >= entry_price + (stop_distance * 2):
    SELL_HALF = True  # zerar 50 % em 2R
    # Levar o stop para o zero a zero nos 50 % restantes

Passo 5: definir filtros (evitar setups ruins)

Que condições invalidam o setup?

• Filtro de horário: Operar só nas 2 primeiras horas do pregão (9:30-11:30 ET)
• Filtro de volatilidade: Pular operações quando o VIX passar de 30 (mercado picotado demais)
• Filtro de tendência: Setups comprados só quando o preço estiver acima da EMA de 50 períodos

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

if current_time < "09:30" or current_time > "11:30":
    SKIP_TRADE = True  # fora da janela de operacao

# Passo 1: condicoes de entrada
swing_low = min([bar.low for bar in last_20_bars])
if current_bar.low < swing_low * 0.997:  # varredura
    if current_bar.close > swing_low:     # recuperou

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

        # Passo 3: tamanho da posicao
        risk_amount = account_equity * 0.02
        size = risk_amount / (entry - stop)

        # Passo 4: gestao da operacao (50 % em 2R)
        profit_target_partial = entry + ((entry - stop) * 2)

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

Implementação completa do bot (estratégia de sweep e reversão)

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

# Configuracao
API_KEY = os.getenv('ALPACA_API_KEY')  # NUNCA deixe fixo no 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 carregar mais de 1,5 vez o capital
MAX_DAILY_LOSS = 0.03     # botao de parada: encerra o dia em -3 %

def get_swing_low(bars, lookback=20):
    # Exclua o candle atual. Se incluir, o fundo relevante E a minima atual,
    # o teste de varredura nunca e verdadeiro e o bot nunca dispara.
    lows = [bar.l for bar in bars[-(lookback + 1):-1]]
    return min(lows)

def check_sweep(current_price, current_low, swing_low):
    # Varredura = minima atual < fundo relevante (0,3 %), depois 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 risco
    by_risk = risk_amount / (entry - stop)
    by_notional = (equity * MAX_NOTIONAL_MULT) / entry  # o controle que faltou ao 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):
    # Pergunte a corretora; nao confie numa variavel local. Um bracket que
    # executou e fechou de madrugada nao pode travar o setup de amanha.
    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"✓ Ordem: {size} acoes @ ${entry} | Stop: ${stop} | Alvo: ${target}")
        return order
    except Exception as e:
        print(f"✗ Ordem falhou: {e}")
        return None

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

    while True:
        try:
            if not api.get_clock().is_open:      # controle 1: horario de pregao
                time.sleep(60)
                continue
            if kill_switch_tripped(api):         # controle 2: limite de perda diaria
                print("🛑 Limite de perda diaria atingido. Vou parar.")
                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)   # controle 3: teto de nocional
                if size > 0:
                    place_bracket_order(api, symbol, size, entry, stop, target)

            time.sleep(60)  # verificar a cada minuto
        except Exception as e:
            print(f"Erro: {e}")
            time.sleep(60)

run_bot()  # ~75 linhas - e as tres que mais importam sao os controles.

O que isso faz: Conecta na Alpaca, busca candles de 1 minuto do SPY, detecta reversões após varredura (a mínima varre abaixo do fundo relevante e depois o recupera), calcula o tamanho com 2 % de risco limitado pelo nocional, envia uma ordem bracket (entrada + stop + alvo de 3R) e repete a cada 60 segundos — mas só com o mercado aberto, só quando a corretora diz que não há posição, e nunca se o dia estiver em -3 %. Disciplina perfeita, zero emoção e três freios.

Simulador ≠ conta real

Seu bot funciona perfeitamente no simulador. Você coloca no real. Ele cai. Ordens são rejeitadas. Você fica sem entender.

Bem-vindo à produção.

Erros comuns (e como tratá-los)

Erros comuns: Tempo de conexão esgotado, ordem rejeitada, execuções parciais, limites de requisição, mercado fechado. Correções: Lógica de repetição (3× com espera exponencial), checagens prévias (saldo, horário, preço), tratamento de execuções parciais, controle de requisições (200 por minuto), checagem de horário (9:30-16 ET). Bots profissionais tratam erros com elegância.

Lógica de repetição (essencial)

import uuid

def place_order_with_retry(api, **order_params):
    """Repetir o envio da ordem ate 3 vezes"""
    max_retries = 3

    # O mesmo id em toda tentativa. Se a primeira requisicao chegou mesmo na
    # corretora e so a resposta se perdeu, a repeticao e rejeitada como
    # duplicada em vez de dobrar sua posicao.
    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  # Deu certo!

        except Exception as e:
            if attempt < max_retries - 1:
                wait = 2 ** attempt  # 1s e depois 2s (espera exponencial)
                print(f"Ordem falhou: {e}. Nova tentativa em {wait}s...")
                time.sleep(wait)
            else:
                # Ultima tentativa falhou
                print(f"Ordem falhou apos {max_retries} tentativas: {e}")
                # Enviar alerta (email, SMS)
                raise  # Relancar a excecao

Monitoramento e alertas (crítico)

Seu bot roda num VPS na nuvem. Você está jantando. Ele bate num erro.

Como você fica sabendo?

Resposta: Com alertas.

import smtplib
from email.mime.text import MIMEText

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

    # Envio pelo SMTP do Gmail - isso exige uma senha de aplicativo do
    # Gmail, nao a senha da conta; a autenticacao basica caiu em 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="🚨 Erro no bot de trading",
        message=f"O bot bateu num erro: {e}"
    )
    raise

Agora você descobre em minutos se algo quebrou.

Hospedagem: onde rodar seu bot

Automação não é configurar e esquecer

Você coloca o bot no ar. Ele opera por um mês. Taxa de sucesso: 65 %. Igual ao backtest. Você está empolgado.

Mês 2: a taxa de sucesso cai para 48 %. Você não entende.

O que aconteceu?

O regime de mercado mudou. Sua estratégia funciona em mercados em tendência. O mercado passou a lateralizar. Seu bot continuou operando. Os resultados sofreram.

Checklist mensal de manutenção do bot

1. Métricas de desempenho: Taxa de acerto dentro de 5 % do backtest? R médio positivo? Drawdown aceitável? Slippage piorou? 2. Registros de erro: Erros de conexão, ordens rejeitadas, casos extremos. 3. Checagem de regime: O mercado ainda favorece a estratégia? VIX elevado → pausar. Volatilidade baixa → rompimentos sofrem.

Se você chegou até aqui, entendeu que automação não é mágica: é execução disciplinada em escala. Programe sua vantagem. Teste com rigor. Coloque no ar com cautela. Monitore sem parar.

Aulas relacionadas