Bot de trading em Python com a Binance API.

A Binance tem uma das APIs mais completas e bem documentadas do mundo cripto, e Python é a linguagem ideal pra explorá-la. Neste tutorial você vai montar a base de um bot de trading real — não um brinquedo. Vamos priorizar três coisas que diferenciam código de hobby de código sério: segurança das chaves, separação de responsabilidades e teste antes de operar.

01Setup do ambiente

Python 3.11+, virtualenv e a biblioteca. Há duas escolhas principais: python-binance (específica, mais direta pra Binance) e ccxt (genérica, funciona em dezenas de exchanges). Pra começar focado, vamos de python-binance.

# Criar projeto e ambiente isolado
mkdir bot-binance && cd bot-binance
python -m venv venv
source venv/bin/activate  # Linux/Mac (Windows: venv\Scripts\activate)

pip install python-binance pandas python-dotenv

02Gerar chaves de API (com segurança)

Na sua conta Binance, vá em Gerenciamento de API e crie uma chave. Regras de ouro de segurança:

• Permissões mínimas: habilite só "Leitura" e "Spot Trading". NUNCA habilite "Saque".
• Restrinja por IP se for rodar em VPS com IP fixo.
• Guarde a Secret Key na hora — ela só aparece uma vez.

Coloque as chaves num arquivo .env (e adicione .env ao .gitignore):

# .env — NUNCA versione este arquivo
BINANCE_API_KEY=sua_chave_aqui
BINANCE_API_SECRET=seu_secret_aqui

03Conectar e puxar candles

Primeiro contato — conectar na testnet (ambiente de teste com saldo fictício) e puxar dados:

# conectar.py
import os
from binance.client import Client
from dotenv import load_dotenv
import pandas as pd

load_dotenv()
# testnet=True usa o ambiente de teste — comece SEMPRE aqui
client = Client(os.getenv("BINANCE_API_KEY"),
                os.getenv("BINANCE_API_SECRET"),
                testnet=True)

def get_candles(symbol="BTCUSDT", interval="15m", limit=100):
    raw = client.get_klines(symbol=symbol, interval=interval, limit=limit)
    df = pd.DataFrame(raw, columns=[
        "open_time","open","high","low","close","volume",
        "close_time","qav","trades","tbav","tqav","ignore"])
    df["close"] = df["close"].astype(float)
    return df

df = get_candles()
print(df[["close"]].tail())

04Calcular o sinal (estratégia em função pura)

Aqui está o princípio que separa código profissional: a estratégia é uma função pura — recebe dados, devolve sinal, sem efeitos colaterais. Isso a torna testável isoladamente, sem conectar em nada. Exemplo com cruzamento de médias + RSI:

# strategy.py
import pandas as pd

def calcular_rsi(series, periodo=14):
    delta = series.diff()
    ganho = delta.clip(lower=0).rolling(periodo).mean()
    perda = -delta.clip(upper=0).rolling(periodo).mean()
    rs = ganho / perda
    return 100 - (100 / (1 + rs))

def calcular_sinal(df: pd.DataFrame) -> str:
    df["ma_rapida"] = df["close"].rolling(9).mean()
    df["ma_lenta"]  = df["close"].rolling(21).mean()
    df["rsi"] = calcular_rsi(df["close"])

    u = df.iloc[-1]
    # Compra: tendência de alta + RSI não sobrecomprado
    if u["ma_rapida"] > u["ma_lenta"] and u["rsi"] < 70:
        return "COMPRA"
    if u["ma_rapida"] < u["ma_lenta"] and u["rsi"] > 30:
        return "VENDA"
    return "AGUARDA"

05Executar ordem (na testnet primeiro!)

Com o sinal calculado, a camada de execução envia a ordem. Note que isto roda na testnet — saldo fictício:

# executor.py
from binance.enums import *

def executar_ordem(client, symbol, sinal, quantidade):
    if sinal == "COMPRA":
        ordem = client.create_order(
            symbol=symbol, side=SIDE_BUY,
            type=ORDER_TYPE_MARKET, quantity=quantidade)
        return ordem
    if sinal == "VENDA":
        ordem = client.create_order(
            symbol=symbol, side=SIDE_SELL,
            type=ORDER_TYPE_MARKET, quantity=quantidade)
        return ordem
    return None  # AGUARDA: não faz nada

06Arquitetura de um bot que não te quebra

Junte as peças com separação clara. Bot sério tem camadas independentes:

# estrutura recomendada
# ├── client.py     # conexão Binance + reconexão
# ├── strategy.py   # funções puras: dados → sinal (testável)
# ├── risk.py       # tamanho de posição, stop, take, limites
# ├── executor.py   # envia ordens, controla estado
# ├── logger.py     # registra tudo (auditoria é vital)
# └── main.py       # loop principal, cola tudo

# main.py — loop básico
import time

while True:
    try:
        df = get_candles()
        sinal = calcular_sinal(df)
        qtd = calcular_tamanho_posicao(saldo, risco_pct=1)  # do risk.py
        if sinal != "AGUARDA":
            executar_ordem(client, "BTCUSDT", sinal, qtd)
            log(sinal, qtd)
        time.sleep(60)  # checa a cada minuto
    except Exception as e:
        log_erro(e)
        time.sleep(30)  # nunca deixe o loop morrer silenciosamente

07Gestão de risco no código

Estratégia define quando entrar; gestão de risco define quanto. Sem a segunda, a primeira não importa. O risk.py deve conter, no mínimo:

• Tamanho de posição baseado em % da banca (ex: arriscar 1% por trade).
• Stop loss automático em toda posição — nunca deixe sem.
• Limite de perda diária que desliga o bot ao ser atingido.
• Máximo de posições simultâneas pra não concentrar risco.

08Testnet e backtest antes do real

Sequência obrigatória antes de qualquer dinheiro real: (1) backtest da função de estratégia sobre dados históricos, (2) testnet da Binance por semanas com saldo fictício em condições reais de mercado, (3) só então real com valor mínimo. Pular qualquer etapa é como dirigir de olhos fechados.

09Perguntas frequentes