Deriv API em Python: conexão WebSocket do zero.

01Por que estudar a Deriv API

Três motivos que fazem dela um bom case técnico: documentação pública e clara, sandbox/demo gratuita pra testes (sem precisar depositar nada), e protocolo WebSocket — que é exatamente o que você vai precisar entender pra conectar em qualquer exchange cripto moderna, MT5 via bridge, ou plataforma com streaming de dados em tempo real. O que você aprende aqui transfere direto pra Binance, Bybit, Deribit.

02Setup do ambiente

Você precisa de Python 3.11+, um virtualenv e duas bibliotecas. No terminal:

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

# Instalar dependências
pip install websockets asyncio python-dotenv

Em seguida, crie uma conta demo na Deriv (gratuita, sem depósito) só pra obter um API token de leitura. Você não precisa depositar nem operar.

1. Acesse app.deriv.com e crie conta demo
2. Vá em Configurações → Tokens de API
3. Crie um token com escopo Read (apenas leitura) pra esse tutorial
4. Copie o token e guarde num arquivo .env no projeto:

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

03Hello World: conectando ao WebSocket

O servidor da Deriv usa WebSocket em wss://ws.derivws.com/websockets/v3. Toda comunicação é assíncrona — você manda uma mensagem JSON, o servidor responde também em JSON, possivelmente em streaming. Primeiro contato:

# 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())

Rode com python conectar.py. Você deve ver {"echo_req": {"ping": 1}, "msg_type": "pong", "ping": "pong"}. Se viu, parabéns — você está conectado. Se não, verifique firewall ou proxy.

04Autenticação

Depois do handshake, autoriza-se com o 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 candles em tempo real

Aqui o WebSocket brilha. Em vez de ficar polling REST a cada segundo, você se inscreve num stream e o servidor empurra atualizações sozinho:

# 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())

O parâmetro subscribe: 1 é a mágica — ele mantém a conexão aberta e empurra cada novo candle. Você não precisa pedir de novo.

06Estruturando como um bot de verdade

O exemplo acima é didático. Bot de verdade tem três camadas separadas: conexão (reconexão automática, heartbeat), estratégia (regras puras, testáveis), e execução (mandar ordens, gerenciar estado). Esqueleto recomendado:

# estrutura/
# ├── client.py       # WebSocket + reconnect + heartbeat
# ├── strategy.py     # Funções puras: dado um DataFrame, retorna sinal
# ├── executor.py     # Manda ordens, controla posição aberta
# ├── risk.py         # Stop loss, take profit, dimensionamento
# └── main.py         # Cola tudo

# 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]

    # Cruzamento pra cima
    if anterior["ma_curta"] < anterior["ma_longa"] and ultima["ma_curta"] > ultima["ma_longa"]:
        return "compra"
    # Cruzamento pra baixo
    if anterior["ma_curta"] > anterior["ma_longa"] and ultima["ma_curta"] < ultima["ma_longa"]:
        return "venda"
    return "hold"

A separação importa: a estratégia em função pura é testável com pytest em segundos, sem precisar conectar em nada. Você roda backtest com 5 anos de dados, valida, e só depois pluga no executor real.

07Tratamento de erros e reconexão

WebSocket em produção vai cair. Servidor reinicia, rede oscila, timeout passa. Bot que não reconecta é bot inútil. Padrão 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)  # exponential, capa em 60s

08Onde aplicar esse conhecimento

O padrão WebSocket + asyncio que você aprendeu funciona em quase toda plataforma moderna com streaming. Onde isso te leva:

• Binance / Bybit — APIs similares, idêntica filosofia. websockets + autenticação + stream de candles. O código quase não muda.
• MT5 via biblioteca Python — não é WebSocket puro, mas a estrutura de "estratégia em função pura + executor" se aplica direto.
• TradingView Webhooks — você fica do outro lado: recebe alertas via HTTP e usa esse padrão pra processar.
• Mercado regulado (B3) — corretoras nacionais oferecem APIs proprietárias; a lógica de stream e separação de camadas continua valendo.