API de Deriv en Python: conexión WebSocket desde cero.

01Por qué estudiar la API de Deriv

Tres motivos que la convierten en un buen caso técnico: documentación pública y clara, sandbox/demo gratuita para pruebas (sin necesidad de depositar nada) y protocolo WebSocket — que es exactamente lo que vas a necesitar entender para conectar con cualquier exchange cripto moderno, con MT5 vía bridge o con cualquier plataforma que haga streaming de datos en tiempo real. Lo que aprendes aquí se transfiere directo a Binance, Bybit, Deribit.

02Preparación del entorno

Necesitas Python 3.11+, un virtualenv y dos librerías. En la terminal:

# Crear proyecto y entorno aislado
mkdir bot-deriv && cd bot-deriv
python -m venv venv
source venv/bin/activate  # Linux/Mac
# venv\Scripts\activate     # Windows

# Instalar dependencias
pip install websockets asyncio python-dotenv

Después, crea una cuenta demo en Deriv (gratuita, sin depósito) solo para obtener un API token de lectura. No necesitas depositar ni operar.

1. Entra en app.deriv.com y crea una cuenta demo
2. Ve a Configuración → Tokens de API
3. Crea un token con alcance Read (solo lectura) para este tutorial
4. Copia el token y guárdalo en un archivo .env en el proyecto:

# .env
DERIV_TOKEN=seu_token_aqui
DERIV_APP_ID=1089  # app_id de pruebas público

03Hello World: conectando al WebSocket

El servidor de Deriv usa WebSocket en wss://ws.derivws.com/websockets/v3. Toda la comunicación es asíncrona — envías un mensaje JSON, el servidor responde también en JSON, posiblemente en streaming. Primer contacto:

# conectar.py
import asyncio, json, os
import websockets
from dotenv import load_dotenv

load_dotenv()
APP_ID = os.getenv("DERIV_APP_ID")
URL    = f"wss://ws.derivws.com/websockets/v3?app_id={APP_ID}"

async def ping():
    async with websockets.connect(URL) as ws:
        await ws.send(json.dumps({"ping": 1}))
        resposta = await ws.recv()
        print("Servidor respondeu:", resposta)

asyncio.run(ping())

Ejecuta con python conectar.py. Deberías ver {"echo_req": {"ping": 1}, "msg_type": "pong", "ping": "pong"}. Si lo viste, enhorabuena — estás conectado. Si no, revisa el firewall o el proxy.

04Autenticación

Tras el handshake, se autoriza con el token:

# autenticar.py
async def autenticar():
    token = os.getenv("DERIV_TOKEN")
    async with websockets.connect(URL) as ws:
        await ws.send(json.dumps({"authorize": token}))
        resp = json.loads(await ws.recv())
        if "error" in resp:
            print("Falha:", resp["error"]["message"])
        else:
            print("Conta:", resp["authorize"]["loginid"])
            print("Saldo:", resp["authorize"]["balance"])

05Streaming de velas en tiempo real

Aquí el WebSocket brilla. En vez de hacer polling REST cada segundo, te suscribes a un stream y el servidor envía las actualizaciones por su cuenta:

# candles.py
async def stream_candles(symbol="frxEURUSD", granularity=60):
    async with websockets.connect(URL) as ws:
        await ws.send(json.dumps({
            "ticks_history": symbol,
            "adjust_start_time": 1,
            "count": 100,
            "end": "latest",
            "style": "candles",
            "granularity": granularity,
            "subscribe": 1
        }))

        while True:
            msg = json.loads(await ws.recv())
            if msg.get("msg_type") == "ohlc":
                c = msg["ohlc"]
                print(f"{c['epoch']} O:{c['open']} H:{c['high']} L:{c['low']} C:{c['close']}")

asyncio.run(stream_candles())

El parámetro subscribe: 1 es la magia — mantiene la conexión abierta y envía cada vela nueva. No hace falta volver a pedirla.

06Estructurando como un bot de verdad

El ejemplo de arriba es didáctico. Un bot de verdad tiene tres capas separadas: conexión (reconexión automática, heartbeat), estrategia (reglas puras, testeables), y ejecución (enviar órdenes, gestionar estado). Esqueleto recomendado:

# estructura/
# ├── client.py       # WebSocket + reconnect + heartbeat
# ├── strategy.py     # Funciones puras: dado un DataFrame, devuelve señal
# ├── executor.py     # Manda órdenes, controla la posición abierta
# ├── risk.py         # Stop loss, take profit, dimensionamiento
# └── main.py         # Une todo

# strategy.py - exemplo: cruzamento de médias
import pandas as pd

def calcular_sinal(df: pd.DataFrame) -> str:
    df["ma_curta"] = df["close"].rolling(9).mean()
    df["ma_longa"] = df["close"].rolling(21).mean()

    ultima = df.iloc[-1]
    anterior = df.iloc[-2]

    # Cruce hacia arriba
    if anterior["ma_curta"] < anterior["ma_longa"] and ultima["ma_curta"] > ultima["ma_longa"]:
        return "compra"
    # Cruce hacia abajo
    if anterior["ma_curta"] > anterior["ma_longa"] and ultima["ma_curta"] < ultima["ma_longa"]:
        return "venda"
    return "hold"

La separación importa: la estrategia como función pura se puede testear con pytest en segundos, sin necesidad de conectarte a nada. Corres el backtest con 5 años de datos, validas, y solo después la enchufas al ejecutor real.

07Manejo de errores y reconexión

Un WebSocket en producción se va a caer. El servidor se reinicia, la red oscila, salta el timeout. Un bot que no reconecta es un bot inútil. Patrón recomendado:

async def conectar_com_retry():
    backoff = 1
    while True:
        try:
            async with websockets.connect(URL, ping_interval=20) as ws:
                print("Conectado")
                backoff = 1  # reset
                await rotina_principal(ws)
        except (websockets.ConnectionClosed, OSError) as e:
            print(f"Conexão caiu: {e}. Reconectando em {backoff}s")
            await asyncio.sleep(backoff)
            backoff = min(backoff * 2, 60)  # exponencial, tope en 60s

08Dónde aplicar este conocimiento

El patrón WebSocket + asyncio que acabas de aprender funciona en casi toda plataforma moderna con streaming. Adónde te lleva:

• Binance / Bybit — APIs similares, filosofía idéntica. websockets + autenticación + stream de velas. El código casi no cambia.
• MT5 vía librería Python — no es WebSocket puro, pero la estructura de «estrategia como función pura + ejecutor» se aplica igual.
• TradingView Webhooks — aquí estás del otro lado: recibes alertas vía HTTP y usas este patrón para procesarlas.
• Mercado regulado (la bolsa brasileña B3) — los brókeres locales ofrecen APIs propietarias; la lógica de stream y la separación de capas siguen valiendo.