Bot de trading con API de Deriv.com en Python

Reseña de Deriv.com

¿Te interesa el trading automatizado y óperas de forma regular en la plataforma de Deriv.com? En este tutorial vamos a mostrar un ejemplo de un bot de trading desarrollado con la API de Deriv.

Se trata de un bot simple que abre posiciones de compra cuando se produce el cruce alcista de dos medias móviles. Básicamente es un bot demostrativo que no debe usarse para operar con dinero real ya que su estrategia es demasiado sencilla y no cuenta con reglas de gestión monetaria, gestión de riesgo, filtros de las operaciones, etc.

El código abre una posición long en un contrato (en este caso R_100) cada vez que la media móvil de corto plazo cruza al alza la media móvil de largo plazo.

¿Quieres obtener más información de Deriv.com y sus servicios de corretaje online? Más información en: Reseña de Deriv.com

A continuación, vamos a explicar en detalle el código.

(En próximos artículos vamos a mostrar como agregar stop loss y filtros como el ADX, RSI y apertura de contratos bajistas)

Código del bot de Deriv.com en Python

En el código que mostramos a continuación incluimos un pequeño código que básicamente muestra los últimos precios recibidos de la API mientras el programa se mantiene activo. Aunque no es necesario fue incluido para mostrar que efectivamente nos hemos conectado a la API de Deriv.com y estamos recibiendo precios que se serán usados para las señales de compra.

import asyncio
import websockets
import json
import numpy as np

API_URL = "wss://ws.derivws.com/websockets/v3?app_id=1089"
API_TOKEN = "TU_API_TOKEN_AQUI"
SYMBOL = "R_100"

FAST_PERIOD = 5
SLOW_PERIOD = 20

prices = []

async def deriv_bot():
    async with websockets.connect(API_URL) as ws:
        await ws.send(json.dumps({"authorize": API_TOKEN}))
        print("✅ Autenticado:", await ws.recv())

        await ws.send(json.dumps({
            "ticks_history": SYMBOL,
            "adjust_start_time": 1,
            "count": 100,
            "end": "latest",
            "start": 1,
            "style": "ticks",
            "subscribe": 1
        }))

        prev_fast_ma = None
        prev_slow_ma = None

        while True:
            msg = await ws.recv()
            data = json.loads(msg)

            if "tick" in data:
                price = float(data["tick"]["quote"])
                prices.append(price)

                # ✅ Cambio temporal: mostrar últimos 10 precios
                print("Últimos precios:", [f"{p:.2f}" for p in prices[-10:]])

                if len(prices) > SLOW_PERIOD:
                    prices.pop(0)

                if len(prices) >= SLOW_PERIOD:
                    fast_ma = np.mean(prices[-FAST_PERIOD:])
                    slow_ma = np.mean(prices[-SLOW_PERIOD:])

                    print(f"MA Rápida: {fast_ma:.2f}, MA Lenta: {slow_ma:.2f}")

                    if prev_fast_ma is not None and prev_slow_ma is not None:
                        if prev_fast_ma <= prev_slow_ma and fast_ma > slow_ma:
                            print(" Cruce alcista detectado → Enviando COMPRA")
                            await abrir_compra(ws, SYMBOL)

                    prev_fast_ma = fast_ma
                    prev_slow_ma = slow_ma


async def abrir_compra(ws, symbol):
    contract = {
        "buy": 1,
        "parameters": {
            "amount": 1,
            "basis": "stake",
            "contract_type": "CALL",
            "currency": "USD",
            "duration": 1,
            "duration_unit": "m",
            "symbol": symbol
        }
    }
    await ws.send(json.dumps(contract))
    print(" Respuesta de la orden:", await ws.recv())


asyncio.get_event_loop().run_until_complete(deriv_bot())

Ahora vamos a explicar en detalle este código:

Bibliotecas importadas y variables iniciales

import asyncio
import websockets
import json
import numpy as np

asyncio: Esta biblioteca permite usar programación asíncrona, esencial para recibir datos en tiempo real sin bloquear el código.
websockets: Permite que el bot se conecte con la API de Deriv vía WebSocket.
json: Se usa para enviar y recibir datos en formato JSON (el que usa Deriv API).
numpy: Es una librería que permite el manejo de datos y entre otras cosas sirve para calcular fácilmente medias móviles y otros cálculos numéricos (la vamos a usar para calcular otros indicadores más adelante).

API_URL = "wss://ws.derivws.com/websockets/v3?app_id=1089"
API_TOKEN = "TU_API_TOKEN_AQUI"
SYMBOL = "R_100"
FAST_PERIOD = 5
SLOW_PERIOD = 20
prices = []

Estas son las variables iniciales del bot las cuáles podemos modificar:

API_URL: Aquí indicamos la dirección de la API de Deriv con WebSockets.
API_TOKEN: Es nuestro token personal de Deriv.com para autenticar la conexión a la API.
SYMBOL: Es el activo que quieres analizar (ej. R_100 = índice sintético).
FAST_PERIOD y SLOW_PERIOD: Es el periodo de las medias móviles rápida y lenta.
prices: Es la lista donde guardaremos los precios recibidos para calcular las medias móviles.

Función principal del bot con asyncio

async def deriv_bot():
    async with websockets.connect(API_URL) as ws:
        await ws.send(json.dumps({"authorize": API_TOKEN}))
        print("✅ Autenticado:", await ws.recv())

async def: Nos permite definir una función asíncrona, necesaria para WebSockets.
websockets.connect(API_URL): Esto permite abrir la conexión con el servidor de Deriv.
ws.send(json.dumps({“authorize”: API_TOKEN})): Con este código enviamos nuestro token de API para autenticación.
await ws.recv(): Con esto indicamos que espere la respuesta del servidor (confirmación de autenticación).

Código de suscripción a ticks (precios en tiempo real)

await ws.send(json.dumps({
    "ticks_history": SYMBOL,
    "adjust_start_time": 1,
    "count": 100,
    "end": "latest",
    "start": 1,
    "style": "ticks",
    "subscribe": 1
}))

))

“ticks_history”: Con esto pedimos datos de ticks del símbolo.
“count”: 100: Esto nos da los últimos 100 ticks históricos.
“subscribe”: 1: Esto indica que queremos suscripción continua (recibir ticks nuevos en tiempo real).

Variables para detectar cruces de medias móviles (SMA)

prev_fast_ma = None
prev_slow_ma = None

Ambas variables almacenan el periodo de la media móvil de corto plazo y la media móvil de largo plazo.

Bucle principal que recibe ticks de la API

while True:
    msg = await ws.recv()
    data = json.loads(msg)

    if "tick" in data:
        price = float(data["tick"]["quote"])
        prices.append(price)

await ws.recv() → espera el siguiente tick.
json.loads(msg) → decodifica el JSON recibido.
price = float(data[“tick”][“quote”]) → obtenemos el precio actual.
prices.append(price) → lo guardamos en nuestra lista de precios.

Impresión de los últimos cambios de precios

print("Últimos precios:", [f"{p:.2f}" for p in prices[-10:]])

Muestra los últimos 10 precios recibidos, útil para seguimiento y depuración.
Es un cambio temporal que se puede eliminar después.

Código para mantener sólo los últimos N precios

if len(prices) > SLOW_PERIOD:
    prices.pop(0)

Este código asegura que la lista prices no crezca indefinidamente, solo necesitamos los últimos SLOW_PERIOD ticks para calcular la media lenta.

Cálculo de las medias móviles

if len(prices) >= SLOW_PERIOD:
    fast_ma = np.mean(prices[-FAST_PERIOD:])
    slow_ma = np.mean(prices[-SLOW_PERIOD:])

fast_ma: Nos da el promedio de los últimos FAST_PERIOD precios.
slow_ma: Nos da el promedio de los últimos SLOW_PERIOD precios.

Solo se calcula si tenemos suficientes datos (len(prices) >= SLOW_PERIOD).

Detección de los cruces alcistas de medias móviles

if prev_fast_ma is not None and prev_slow_ma is not None:
    if prev_fast_ma <= prev_slow_ma and fast_ma > slow_ma:
        print(" Cruce alcista detectado → Enviando COMPRA")
        await abrir_compra(ws, SYMBOL)

Compara las medias móviles del tick anterior y actual.
Condición: prev_fast_ma ≤ prev_slow_ma y fast_ma > slow_ma.
Solo dispara la compra en el momento exacto del cruce.

Almacenamiento de valores previos

prev_fast_ma = fast_ma
prev_slow_ma = slow_ma

Estas líneas actualizan las medias móviles previas para el próximo tick.

Función de apertura de posiciones de compra

async def abrir_compra(ws, symbol):
    contract = {
        "buy": 1,
        "parameters": {
            "amount": 1,
            "basis": "stake",
            "contract_type": "CALL",
            "currency": "USD",
            "duration": 1,
            "duration_unit": "m",
            "symbol": symbol
        }
    }
    await ws.send(json.dumps(contract))
    print(" Respuesta de la orden:", await ws.recv())

Crea un contrato CALL (compra) de 1 minuto con monto 1 USD.
Envía la orden a Deriv vía WebSocket.
Imprime la respuesta del servidor (confirmación de la operación).

Ejecución del bot

asyncio.get_event_loop().run_until_complete(deriv_bot())

Esta función inicia la función asíncrona principal.
Permite que el bot corra infinitamente recibiendo ticks y detectando cruces.

Resumen

Conecta con Deriv API y se autentica.
Se suscribe a ticks en tiempo real.
Calcula medias móviles rápida y lenta.
Detecta cruces alcistas exactos.
Abre una operación CALL cuando ocurre el cruce.
Muestra los últimos precios (temporal).

Mientras se ejecuta el código y espera las condiciones adecuadas para la apertura de posiciones de compra, el bot también imprime los datos de precios más recientes del contrato:

bot trading deriv

¿Qué mejoras podemos agregarle a este bot?

Como indicamos este bot es simplemente demostrativo y no debe usarse para operar con dinero real. Antes es necesario implementar una serie de mejoras, como, por ejemplo:

Apertura de posiciones bajistas
Uso de stop loss para el cierre de posiciones perdedoras
Gestión monetaria (tamaño de posición)
Filtros de volatilidad como el ATR
Filtros adicionales como el RSI, oscilador estocástico y otros.

Aunque esto aumenta la complejidad del código ciertamente nos permitirá contar con un bot que si utilice una estrategia más robusta. En próximos artículos vamos a mostrar como incluir estas funciones en el código de nuestro bot. Manténganse atentos.

¿Quieren abrir una cuenta con Deriv.com y usar su API y otros servicios de trading? Pueden ingresar a su sitio web mediante:

Ir al sitio web de Deriv