Bot de trading em Python com a Binance API.

Binance has one of the most complete APIs e bem documentadas do mundo cripto, e Python é a linguagem ideal for 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 before de operar.

01Setup do ambiente

Python 3.11+, virtualenv e a biblioteca. Há duas escolhas principais: python-binance (específica, mais direta for 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 (strategy em função pura)

Aqui está o princípio que separa código profissional: a strategy is a função pura — recebe dados, devolve sinal, without efeitos colaterais. Isso a torna testável isoladamente, without 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: trend 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 execution 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 each minuto
    except Exception as e:
        log_erro(e)
        time.sleep(30)  # never deixe o loop morrer silenciosamente

07Gestão de risco no código

Strategy define when entrar; risk management 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 — never deixe sem.
• Limite de perda diária que desliga o bot ao ser atingido.
• Máximo de posições simultâneas to not concentrar risco.

08Testnet e backtest before do real

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

09Pertanyaan yang sering diajukan