Trading Algoritmico com Python: Como Criar Bots de Investimento em 2026

Trading algoritmico usa programacao para executar operacoes no mercado financeiro baseado em regras predefinidas. Com Python, voce pode criar robos que analisam dados, identificam oportunidades e executam ordens automaticamente. Este guia mostra como comecar do zero com responsabilidade.

Aviso importante sobre riscos

Trading algoritmico envolve riscos reais de perda financeira. Este guia e educacional — nao constitui recomendacao de investimento. Nunca invista dinheiro que voce nao pode perder. Teste exaustivamente em ambiente simulado antes de usar dinheiro real. Resultados passados nao garantem resultados futuros.

Conceitos fundamentais

Backtesting: simular sua estrategia em dados historicos para ver como teria performado no passado. E o primeiro passo antes de qualquer operacao real.

Estrategia: conjunto de regras que define quando comprar e quando vender. Pode ser baseada em indicadores tecnicos (medias moveis, RSI, MACD), padroes estatisticos (mean reversion, momentum), ou dados alternativos (sentimento de noticias, dados on-chain).

Execucao: envio automatico de ordens para a corretora via API quando a estrategia identifica uma oportunidade.

Obtendo dados de mercado com Python

import yfinance as yf
import pandas as pd

# Baixar dados historicos
df = yf.download(“PETR4.SA”, start=”2024-01-01″, end=”2026-03-15″, interval=”1d”)

# Calcular indicadores
df[“SMA_20”] = df[“Close”].rolling(window=20).mean()
df[“SMA_50”] = df[“Close”].rolling(window=50).mean()
df[“RSI”] = calcular_rsi(df[“Close”], 14)

def calcular_rsi(precos, periodos=14):
delta = precos.diff()
ganho = delta.where(delta > 0, 0).rolling(window=periodos).mean()
perda = (-delta.where(delta < 0, 0)).rolling(window=periodos).mean()
rs = ganho / perda
return 100 – (100 / (1 + rs))

yfinance e gratuito e suporta acoes brasileiras (sufixo .SA), americanas, ETFs, criptomoedas e outros ativos. Para dados em tempo real com menor latencia, use APIs pagas como Alpha Vantage, Polygon.io ou a API da sua corretora.

Estrategia de cruzamento de medias moveis

Uma das estrategias mais classicas: comprar quando a media curta cruza acima da media longa (sinal de alta), vender quando cruza abaixo (sinal de baixa):

def estrategia_cruzamento_medias(df, curta=20, longa=50):
df[“SMA_curta”] = df[“Close”].rolling(window=curta).mean()
df[“SMA_longa”] = df[“Close”].rolling(window=longa).mean()

df[“sinal”] = 0
df.loc[df[“SMA_curta”] > df[“SMA_longa”], “sinal”] = 1 # Comprado
df.loc[df[“SMA_curta”] <= df["SMA_longa"], "sinal"] = -1 # Vendido

df["posicao"] = df["sinal"].diff()
# posicao = 2: sinal de compra (mudou de -1 para 1)
# posicao = -2: sinal de venda (mudou de 1 para -1)

return df

Backtesting com Backtrader

Backtrader e a biblioteca Python mais usada para backtesting:

import backtrader as bt

class EstrategiaMediaMovel(bt.Strategy):
params = ((“curta”, 20), (“longa”, 50),)

def __init__(self):
self.sma_curta = bt.indicators.SMA(self.data.close, period=self.params.curta)
self.sma_longa = bt.indicators.SMA(self.data.close, period=self.params.longa)
self.crossover = bt.indicators.CrossOver(self.sma_curta, self.sma_longa)

def next(self):
if self.crossover > 0: # Cruzou para cima
self.buy(size=100)
elif self.crossover < 0: # Cruzou para baixo
self.sell(size=100)

cerebro = bt.Cerebro()
cerebro.addstrategy(EstrategiaMediaMovel)
data = bt.feeds.PandasData(dataname=df)
cerebro.adddata(data)
cerebro.broker.setcash(100000)
cerebro.run()
cerebro.plot()

Conectando a uma corretora

Para operar de verdade, voce precisa de uma corretora com API. No Brasil: Clear (via MetaTrader 5 + API Python), XP/Rico (via API proprietaria), BTG Pactual (API para investidores qualificados).

Para criptomoedas: Binance, Bybit e Coinbase tem APIs REST e WebSocket bem documentadas.

Exemplo com ccxt (biblioteca que abstrai 100+ exchanges de crypto):

import ccxt

exchange = ccxt.binance({
“apiKey”: “sua_api_key”,
“secret”: “seu_secret”,
})

# Consultar saldo
saldo = exchange.fetch_balance()

# Criar ordem de compra limitada
ordem = exchange.create_limit_buy_order(“BTC/USDT”, 0.001, 45000)

Gerenciamento de risco

Stop loss: limite de perda por operacao (ex: 2% do capital). Take profit: alvo de ganho por operacao. Tamanho da posicao: nunca arriscar mais de 1-2% do capital total em uma unica operacao (regra de Kelly). Diversificacao: operar em multiplos ativos para reduzir risco. Circuit breaker: parar o bot automaticamente se perder X% no dia.