7 regras de gestão de risco obrigatórias para bots

Por que bot precisa de regras MAIS rígidas que humano

Humano em tilt comete 5-10 trades ruins em sequência. Bot bugado pode fazer 500 em segundos.

Casos reais documentados:

• Knight Capital (2012): bug em deploy fez perder US$ 460 milhões em 45 minutos
• Trader retail UK (2019): bot com loop de erro fez 1.200 trades em 3 horas, perdeu £15.000
• Trader BR (2023, documentado em fórum): bot Deriv esqueceu daily stop, perdeu R$ 8.000 em 1 noite

Em código, “esquecer” uma checagem não é falha do humano — é bug que executa indefinidamente. As 7 regras protegem contra isso.

Regra 1: Daily Loss Limit absoluto

O que é: bot PARA automaticamente se perdas do dia atingem limite predefinido.

Implementação:

# Check ANTES de cada trade
DAILY_LOSS_LIMIT = -50  # em USD

if daily_pnl <= DAILY_LOSS_LIMIT:
    log.critical(f"DAILY LOSS LIMIT HIT: {{daily_pnl}}")
    notify_telegram("Bot parado: daily loss")
    bot.stop()
    sys.exit(1)  # mata processo completamente

Como calibrar:

• Conservador: 1-2% do capital total
• Moderado: 3-5%
• Agressivo (NÃO recomendado): 10%+

Importante: limite é em USD/equivalente, NÃO em número de trades. Trade-count pode mascarar perdas grandes.

Regra 2: Daily Win Cap (sim, parar de ganhar)

Conceito contraintuitivo: bot deve PARAR depois de atingir target.

Por quê:

• Streak de vitórias frequentemente precede streak de derrotas (regression to mean)
• Ganhar muito alimenta overconfidence (mesmo em bot — você intervém no código)
• Mais trades = mais oportunidades para bug se manifestar
• Preservar lucro > tentar maximizar

DAILY_PROFIT_TARGET = 75

if daily_pnl >= DAILY_PROFIT_TARGET:
    log.info(f"Daily target hit: {{daily_pnl}}")
    notify_telegram(f"Bot parado: target ${{DAILY_PROFIT_TARGET}}")
    bot.stop()

Calibração: target tipicamente 1.5-2x do daily loss limit.

Regra 3: Max consecutive losses

Bot para após N perdas consecutivas. Sinal de que condições mudaram ou bot tem bug.

MAX_CONSECUTIVE_LOSSES = 5
consecutive_losses = 0

def on_trade_close(profit):
    global consecutive_losses
    if profit < 0:
        consecutive_losses += 1
        if consecutive_losses >= MAX_CONSECUTIVE_LOSSES:
            log.warning(f"Max consecutive losses: {{consecutive_losses}}")
            bot.pause(minutes=60)  # pausa, não kill
            consecutive_losses = 0
    else:
        consecutive_losses = 0  # reset on win

Geralmente pause ao invés de kill — permite recuperação se condição passa.

Regra 4: Position size based on equity (não fixo)

Position size deve ajustar conforme equity sobe/desce. Não use stake fixo.

def calculate_position_size(current_equity, risk_pct=1.0):
    """
    Calculate position size based on current equity.
    Risk 1% means: if stop hit, lose 1% of equity.
    """
    risk_amount = current_equity * (risk_pct / 100)
    stop_distance_usd = STOP_DISTANCE_PIPS * PIP_VALUE
    position_size = risk_amount / stop_distance_usd
    return max(MIN_POSITION, min(position_size, MAX_POSITION))

# A cada trade:
current_equity = api.get_balance()
position_size = calculate_position_size(current_equity, risk_pct=1.0)

Por quê isso importa:

• Em drawdown, position diminui automaticamente (preserva capital)
• Em equity growth, position cresce (composto)
• Estoura risco se você esquecer atualizar manualmente

Regra 5: Heartbeat e health check

Bot deve mandar “estou vivo e funcionando” periodicamente. Se silêncio, algo está errado.

async def heartbeat():
    while True:
        equity = await api.get_balance()
        positions = await api.get_open_positions()
        log.info(f"♥️ Equity: ${{equity}}, Open: {{len(positions)}}")

        # Send to monitoring (Telegram, email, etc)
        if minutes_since_last_alert >= 60:
            notify_telegram(f"♥️ Bot OK | Equity: ${{equity}}")

        await asyncio.sleep(300)  # every 5 min

Implemente:

• Telegram bot para notificações (gratuito)
• Email backup se Telegram falhar
• Log file rotativo (não fica gigante)
• Monitoramento externo (uptimerobot.com ou similar)

Regra 6: Try/except em TUDO crítico

Bot Python sem error handling = bomba relógio. Wrap todas as operações críticas:

async def place_trade_safely(direction, stake):
    try:
        contract_id = await api.buy({{...}})
        log.info(f"Trade OK: {{contract_id}}")
        return contract_id

    except ConnectionError as e:
        log.error(f"Connection lost: {{e}}")
        await reconnect()
        return None

    except InsufficientBalance:
        log.critical("Saldo insuficiente! Parando bot.")
        bot.stop()
        return None

    except Exception as e:
        log.exception(f"Unexpected error: {{e}}")
        notify_telegram(f"⚠️ Erro: {{e}}")
        bot.pause(minutes=10)
        return None

Categorias críticas que SEMPRE precisam try/except:

• Conexão com API (broker)
• Execução de ordens
• Leitura de tick/price feed
• Cálculos com dados externos
• Operações de arquivo/banco de dados

Regra 7: Kill switch manual + auto

Você DEVE conseguir parar o bot a qualquer momento de fora.

Kill switch manual:

# Check arquivo "KILL" no diretório do bot
if os.path.exists("KILL"):
    log.critical("KILL file detected. Stopping bot.")
    bot.stop()
    os.remove("KILL")
    sys.exit(0)

# Para parar bot manualmente:
# touch KILL  (Linux/Mac)
# type nul > KILL  (Windows)

Kill switch via Telegram:

# Bot Telegram aceita comando /kill
@bot.message_handler(commands=['kill'])
def kill_handler(message):
    if message.from_user.id != AUTHORIZED_USER_ID:
        return  # só você pode
    log.critical("KILL via Telegram")
    trading_bot.emergency_stop()
    bot.reply_to(message, "Bot parado.")

Auto kill switch (drawdown extreme):

MAX_DRAWDOWN_KILL = -200  # USD absoluto
WEEKLY_KILL_LIMIT = -100

if total_drawdown <= MAX_DRAWDOWN_KILL:
    notify_telegram("🚨 EMERGENCY KILL: max drawdown")
    bot.kill()  # não pause - kill

Kill switches são última linha de defesa. Você não vai usar quase nunca, mas precisa estar lá para quando precisar.

Checklist completo antes de operar

O custo de pular essas regras

Cada regra parece “exagero” até o dia que salvaria sua conta. Casos vistos:

• Sem daily limit: bot fez 250 trades durante NFP, perdeu 80% conta em 2h
• Sem kill switch: trader em viagem, bot bugou, blevou conta em 8h sem ele poder fazer nada
• Sem position sizing dinâmico: em drawdown de 50%, position continuou tamanho original, blevou em + 1 trade
• Sem try/except: exception não tratada parou bot durante trade aberto, posição ficou esquecida
• Sem heartbeat: bot crashou em 2:00 AM, ninguém notou até dia seguinte

Programar essas regras leva 4-8 horas. Pode salvar R$ 5.000-50.000.