Seu primeiro bot Python com Deriv API

Por que Python + API vs DBot

Pré-requisitos honestos

Você não precisa ser Senior Developer, mas:

• Conforto com terminal (cmd/bash) básico
• Conceitos de variáveis, loops, funções
• Python instalado (3.9+)
• Editor: VS Code ou Cursor (gratuitos)
• Conta Deriv (real ou demo)
• ~10-20 horas para chegar em bot básico funcional

Setup do ambiente

Passo 1: Instalar Python

Baixe Python 3.11+ de python.org. No Windows, marque “Add to PATH” durante install.

Passo 2: Verificar instalação

# Abra terminal/cmd e digite:
python --version
# Deve mostrar: Python 3.11.x ou superior

Passo 3: Criar pasta do projeto

mkdir meu_bot_deriv
cd meu_bot_deriv

Passo 4: Ambiente virtual (opcional mas recomendado)

python -m venv venv

# Windows:
venv\Scripts\activate

# Linux/Mac:
source venv/bin/activate

Passo 5: Instalar libraries necessárias

pip install python-deriv-api websockets pandas numpy

Obter API Token

1. Login em deriv.com
2. Acesse “Settings” → “API token”
3. Crie novo token com permissões:
   • Read (sempre)
   • Trade (para executar ordens)
   • Payments (NÃO marque — segurança)
   • Admin (NÃO marque — segurança)
4. Copie o token (você só vê uma vez)
5. Guarde com segurança (não commitar no Git!)

Primeiro bot — Hello World

Vamos começar com bot mínimo que apenas conecta, autentica e mostra saldo.

# bot_hello.py - Conexão básica com Deriv API
import asyncio
import os
from deriv_api import DerivAPI

# SEU TOKEN AQUI (idealmente carregado de .env)
API_TOKEN = os.getenv("DERIV_TOKEN", "SEU_TOKEN_AQUI")
APP_ID = 1089  # public app_id para teste

async def main():
    api = DerivAPI(app_id=APP_ID)

    # Autenticar
    auth = await api.authorize(API_TOKEN)
    print("Autenticado como:", auth["authorize"]["loginid"])

    # Obter saldo
    balance = await api.balance()
    bal = balance["balance"]
    print(f"Saldo: {{bal['balance']}} {{bal['currency']}}")

    # Fechar conexão
    await api.clear()

if __name__ == "__main__":
    asyncio.run(main())

Rodar: python bot_hello.py

Resultado esperado:

Autenticado como: VRTC1234567
Saldo: 10000.00 USD

Se funcionou: parabéns, você está conectado oficialmente à API.

Bot 2: Receber preços em tempo real

Próximo passo: subscrever a ticks (preços) em tempo real.

# bot_ticks.py - Receber ticks ao vivo
import asyncio
import os
from deriv_api import DerivAPI

API_TOKEN = os.getenv("DERIV_TOKEN")
APP_ID = 1089

async def main():
    api = DerivAPI(app_id=APP_ID)
    await api.authorize(API_TOKEN)

    # Subscrever a ticks do EUR/USD
    symbol = "frxEURUSD"  # Use "R_75" para V75 synthetic

    ticks_sub = await api.subscribe({{"ticks": symbol}})

    count = 0
    async for tick in ticks_sub:
        price = tick["tick"]["quote"]
        epoch = tick["tick"]["epoch"]
        print(f"Tick #{{count}}: {{symbol}} = {{price}}")
        count += 1

        # Parar após 10 ticks (demo)
        if count >= 10:
            break

    await api.clear()

asyncio.run(main())

Você verá 10 ticks consecutivos do EUR/USD aparecendo no terminal.

Bot 3: Executar primeiro trade

Agora vamos colocar uma ordem real (em demo!):

# bot_first_trade.py - Primeira ordem real
import asyncio
import os
from deriv_api import DerivAPI

API_TOKEN = os.getenv("DERIV_TOKEN")
APP_ID = 1089

async def main():
    api = DerivAPI(app_id=APP_ID)
    auth = await api.authorize(API_TOKEN)

    # SAFETY CHECK: confirmar que é conta DEMO
    is_demo = "VRTC" in auth["authorize"]["loginid"]
    if not is_demo:
        print("❌ ABORT: Esta não é conta DEMO!")
        await api.clear()
        return

    print("✅ Confirmado: conta DEMO")

    # Definir parâmetros do trade
    proposal_request = {{
        "proposal": 1,
        "amount": 1,           # $1 stake
        "basis": "stake",
        "contract_type": "CALL",  # Rise (preço sobe)
        "currency": "USD",
        "duration": 5,
        "duration_unit": "t",    # t = ticks
        "symbol": "R_75"      # Volatility 75 Index
    }}

    # Obter proposta de contrato
    proposal = await api.proposal(proposal_request)
    proposal_id = proposal["proposal"]["id"]
    payout = proposal["proposal"]["payout"]
    print(f"Proposta ID: {{proposal_id}}, Payout: ${{payout}}")

    # Comprar contrato
    buy_response = await api.buy({{
        "buy": proposal_id,
        "price": 1  # max price willing to pay
    }})

    contract_id = buy_response["buy"]["contract_id"]
    print(f"✅ Comprado! Contract ID: {{contract_id}}")
    print("Aguardando resultado...")

    # Aguardar resultado
    await asyncio.sleep(10)  # 5 ticks ≈ poucos segundos

    # Verificar resultado
    contract = await api.proposal_open_contract({{
        "proposal_open_contract": 1,
        "contract_id": contract_id
    }})

    profit = contract["proposal_open_contract"]["profit"]
    status = contract["proposal_open_contract"]["status"]
    print(f"Status: {{status}}, P/L: ${{profit}}")

    await api.clear()

asyncio.run(main())

Você acabou de executar primeira ordem programática! Confira no painel da Deriv.

Bot 4: Estratégia simples com gestão de risco

Agora juntando tudo em bot completo:

# Bot simples: 3 ticks consecutivos abaixo = compra "Rise"
# Stop daily: -$10. Target daily: +$15.
import asyncio
import os
from deriv_api import DerivAPI
from collections import deque

API_TOKEN = os.getenv("DERIV_TOKEN")
APP_ID = 1089
SYMBOL = "R_75"
STAKE = 1
DAILY_STOP = -10
DAILY_TARGET = 15

async def place_trade(api, direction):
    proposal = await api.proposal({{
        "proposal": 1,
        "amount": STAKE,
        "basis": "stake",
        "contract_type": direction,
        "currency": "USD",
        "duration": 5,
        "duration_unit": "t",
        "symbol": SYMBOL
    }})
    buy = await api.buy({{"buy": proposal["proposal"]["id"], "price": STAKE}})
    return buy["buy"]["contract_id"]

async def wait_result(api, contract_id):
    while True:
        contract = await api.proposal_open_contract({{
            "proposal_open_contract": 1,
            "contract_id": contract_id
        }})
        c = contract["proposal_open_contract"]
        if c["is_sold"]:
            return c["profit"]
        await asyncio.sleep(1)

async def main():
    api = DerivAPI(app_id=APP_ID)
    await api.authorize(API_TOKEN)

    daily_pnl = 0
    trade_count = 0
    last_ticks = deque(maxlen=3)

    ticks_sub = await api.subscribe({{"ticks": SYMBOL}})

    async for tick_msg in ticks_sub:
        tick = tick_msg["tick"]["quote"]
        last_ticks.append(tick)

        # Check stop / target
        if daily_pnl <= DAILY_STOP:
            print(f"🛑 Stop diário atingido: ${{daily_pnl}}")
            break
        if daily_pnl >= DAILY_TARGET:
            print(f"🎯 Target diário atingido: ${{daily_pnl}}")
            break

        # Lógica simples: 3 ticks descendentes = compra Rise
        if len(last_ticks) == 3:
            if last_ticks[0] > last_ticks[1] > last_ticks[2]:
                print(f"Sinal CALL detectado. P/L atual: ${{daily_pnl}}")
                contract_id = await place_trade(api, "CALL")
                profit = await wait_result(api, contract_id)
                daily_pnl += profit
                trade_count += 1
                print(f"Trade #{{trade_count}}: P/L=${{profit}}, Total=${{daily_pnl}}")
                last_ticks.clear()

    await api.clear()

asyncio.run(main())

Próximos passos

Bot básico funcional. A partir daqui:

1. Adicione logging em arquivo (não só print)
2. Implemente error handling (try/except, reconexão)
3. Adicione indicadores (RSI, EMA via pandas)
4. Backtest com dados históricos via API ticks_history
5. Deploy em VPS para rodar 24/7
6. Monitoramento via Telegram bot

Cada passo é tutorial separado. Use AI (Claude/ChatGPT) para te guiar em cada um.