Python + Deriv API: Cara Membuat Trading Bot Pertama Anda

pip install python-deriv-api websockets

pip install numpy pandas ta-lib

import asyncio
from deriv_api import DerivAPI

APP_ID = 1089  # Replace dengan App ID Anda
API_TOKEN = "your_api_token"  # Dari Deriv API settings

async def connect_to_deriv():
    """Connect ke Deriv API."""
    api = DerivAPI(app_id=APP_ID)
    
    # Authorize dengan token
    authorize = await api.authorize(API_TOKEN)
    print(f"✓ Authorized: {authorize['authorize']['loginid']}")
    
    # Get balance
    balance = await api.balance()
    print(f"Balance: {balance['balance']['balance']} {balance['balance']['currency']}")
    
    return api

# Run
loop = asyncio.get_event_loop()
api = loop.run_until_complete(connect_to_deriv())

async def stream_ticks(api, symbol="R_75"):
    """Stream ticks real-time untuk symbol."""
    print(f"Streaming ticks untuk {symbol}...")
    
    # Subscribe ke ticks
    source = await api.subscribe({
        'ticks': symbol,
        'subscribe': 1
    })
    
    async for tick in source:
        if 'tick' in tick:
            print(f"Tick: {tick['tick']['quote']} at {tick['tick']['epoch']}")

# Run
await stream_ticks(api, "R_75")  # Volatility 75 Index

async def buy_rise_fall(api, symbol="R_75", duration=5, stake=1.0, direction="CALL"):
    """Buy Rise (CALL) atau Fall (PUT) contract."""
    
    # Get price proposal first
    proposal = await api.proposal({
        'amount': stake,
        'basis': 'stake',
        'contract_type': direction,  # CALL = Rise, PUT = Fall
        'currency': 'USD',
        'duration': duration,
        'duration_unit': 't',  # ticks
        'symbol': symbol
    })
    
    if 'proposal' not in proposal:
        print(f"Error: {proposal}")
        return None
    
    # Buy contract
    buy = await api.buy({
        'buy': proposal['proposal']['id'],
        'price': stake
    })
    
    contract_id = buy['buy']['contract_id']
    print(f"✓ Contract bought: {contract_id}, Buy price: ${stake}")
    return contract_id

# Buy Rise dengan $1, 5 ticks
contract_id = await buy_rise_fall(api, "R_75", 5, 1.0, "CALL")

import numpy as np
from deriv_api import DerivAPI
import asyncio

class RSIBot:
    def __init__(self, api, symbol="R_75", rsi_period=14, rsi_oversold=30):
        self.api = api
        self.symbol = symbol
        self.rsi_period = rsi_period
        self.rsi_oversold = rsi_oversold
        self.prices = []
        self.stake = 1.0
        self.max_loss = 20.0  # Stop at $20 loss
        self.total_pnl = 0.0
    
    def calculate_rsi(self, prices, period=14):
        """Calculate RSI dari list of prices."""
        if len(prices) < period + 1:
            return None
        
        deltas = np.diff(prices)
        gains = np.where(deltas > 0, deltas, 0)
        losses = np.where(deltas < 0, -deltas, 0)
        
        avg_gain = np.mean(gains[-period:])
        avg_loss = np.mean(losses[-period:])
        
        if avg_loss == 0:
            return 100
        
        rs = avg_gain / avg_loss
        return 100 - (100 / (1 + rs))
    
    async def run(self):
        """Main bot loop."""
        # Subscribe ke ticks
        source = await self.api.subscribe({
            'ticks': self.symbol,
            'subscribe': 1
        })
        
        async for tick_data in source:
            if 'tick' not in tick_data:
                continue
            
            price = float(tick_data['tick']['quote'])
            self.prices.append(price)
            
            # Keep only last 100 prices (memory management)
            if len(self.prices) > 100:
                self.prices = self.prices[-100:]
            
            rsi = self.calculate_rsi(self.prices, self.rsi_period)
            if rsi is None:
                continue
            
            print(f"Price: {price:.5f}, RSI: {rsi:.2f}")
            
            # Trade jika RSI oversold
            if rsi < self.rsi_oversold:
                print(f"🟢 RSI oversold ({rsi:.2f}) - Buy Rise!")
                contract_id = await self.buy_rise()
                
                # Wait untuk contract selesai
                result = await self.check_result(contract_id)
                self.total_pnl += result
                print(f"P/L: ${result:.2f}, Total: ${self.total_pnl:.2f}")
                
                # Stop jika loss limit hit
                if self.total_pnl <= -self.max_loss:
                    print("⛔ Max loss reached. Stopping bot.")
                    break
    
    async def buy_rise(self):
        """Buy CALL (Rise) contract."""
        proposal = await self.api.proposal({
            'amount': self.stake,
            'basis': 'stake',
            'contract_type': 'CALL',
            'currency': 'USD',
            'duration': 5,
            'duration_unit': 't',
            'symbol': self.symbol
        })
        buy = await self.api.buy({
            'buy': proposal['proposal']['id'],
            'price': self.stake
        })
        return buy['buy']['contract_id']
    
    async def check_result(self, contract_id):
        """Wait dan get hasil contract."""
        result = await self.api.proposal_open_contract({
            'contract_id': contract_id,
            'subscribe': 1
        })
        # Logic untuk wait sampai selesai...
        # Simplified - dalam production butuh proper async handling
        return result.get('profit', 0)

# Run bot
async def main():
    api = await connect_to_deriv()
    bot = RSIBot(api)
    await bot.run()

asyncio.run(main())

# Update system
sudo apt update && sudo apt upgrade -y

# Install Python
sudo apt install python3 python3-pip -y

# Clone your bot repo
git clone https://github.com/yourusername/deriv-bot.git
cd deriv-bot

# Install dependencies
pip3 install -r requirements.txt

# Run dengan nohup (background)
nohup python3 bot.py > bot.log 2>&1 &

# Atau gunakan systemd untuk auto-restart
sudo systemctl enable deriv-bot.service