Bot de trading en Python con la Binance API.

Binance tiene una de las APIs más completas y mejor documentadas del mundo cripto, y Python es el lenguaje ideal para explorarla. En este tutorial vas a montar la base de un bot de trading real — no un juguete. Vamos a priorizar tres cosas que separan el código de hobby del código serio: seguridad de las claves, separación de responsabilidades y prueba antes de operar.

01Configuración del entorno

Python 3.11+, virtualenv y la librería. Hay dos opciones principales: python-binance (específica, más directa para Binance) y ccxt (genérica, funciona en decenas de exchanges). Para empezar enfocados, vamos con python-binance.

# Crear proyecto y entorno aislado
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

02Generar claves de API (con seguridad)

En tu cuenta de Binance, ve a Gestión de API y crea una clave. Reglas de oro de seguridad:

• Permisos mínimos: habilita solo "Lectura" y "Spot Trading". NUNCA habilites "Retiro".
• Restringe por IP si vas a ejecutarlo en un VPS con IP fija.
• Guarda la Secret Key en el momento — solo aparece una vez.

Pon las claves en un archivo .env (y añade .env al .gitignore):

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

03Conectar y extraer velas

Primer contacto — conectar a la testnet (entorno de prueba con saldo ficticio) y extraer datos:

# 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 la señal (estrategia como función pura)

Aquí está el principio que separa al código profesional: la estrategia es una función pura — recibe datos, devuelve señal, sin efectos secundarios. Eso la hace testeable de forma aislada, sin conectar con nada. Ejemplo con cruce de medias + 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: tendencia alcista + RSI no 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"

05Ejecutar orden (¡en la testnet primero!)

Con la señal calculada, la capa de ejecución envía la orden. Fíjate en que esto corre en la testnet — saldo ficticio:

# 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  # ESPERA: no hace nada

06Arquitectura de un bot que no te arruina la cuenta

Junta las piezas con separación clara. Un bot serio tiene capas independientes:

# estructura recomendada
# ├── client.py     # conexión Binance + reconexión
# ├── strategy.py   # funciones puras: datos → señal (testeable)
# ├── risk.py       # tamaño de posición, stop, take, límites
# ├── executor.py   # envía órdenes, controla estado
# ├── logger.py     # registra todo (la auditoría es vital)
# └── main.py       # loop principal, une todo

# 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)  # de risk.py
        if sinal != "AGUARDA":
            executar_ordem(client, "BTCUSDT", sinal, qtd)
            log(sinal, qtd)
        time.sleep(60)  # revisa cada minuto
    except Exception as e:
        log_erro(e)
        time.sleep(30)  # nunca deje que el loop muera en silencio

07Gestión de riesgo en el código

La estrategia define cuándo entrar; la gestión de riesgo define cuánto. Sin la segunda, la primera no importa. El risk.py debe contener, como mínimo:

• Tamaño de posición basado en % del capital (ej.: arriesgar 1% por trade).
• Stop loss automático en toda posición — nunca la dejes sin él.
• Límite de pérdida diaria que apaga el bot al alcanzarse.
• Máximo de posiciones simultáneas para no concentrar riesgo.

08Testnet y backtest antes del real

Secuencia obligatoria antes de cualquier dinero real: (1) backtest de la función de estrategia sobre datos históricos, (2) testnet de Binance durante semanas con saldo ficticio en condiciones reales de mercado, (3) solo entonces real con el importe mínimo. Saltarse cualquier etapa es como conducir con los ojos cerrados.

09Preguntas frecuentes