Skip to content
TheChatArchiveThe Chat Archive
Mistralmistral-medium-2505· Mistral AIHugging Face LMArena Human Preference 140K

Vamos fazer tudo em python e operar o xauusd

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Coherecommand-a-03-2025’s answer.
  1. User

    Vamos fazer tudo em python e operar o xauusd

  2. Mistral Assistant

    Ótimo! Vamos criar um robô de trading em Python para operar XAUUSD (Ouro/Dólar) na Deriv, seguindo a estratégia de virada de tendência com as seguintes regras:

    • Timeframe: 5 minutos
    • Stake inicial: $0.35
    • Martingale: 1.20 (aumento de 20% após perda)
    • Take Profit: $10
    • Stop Loss: $20
    • Indicadores: Cruzamento de SMA (10 e 25 períodos) para detectar viradas de tendência.

    1. Configuração Inicial

    Primeiro, instale as bibliotecas necessárias:

    pip install requests websocket-client pandas numpy python-dotenv
    

    2. Código do Robô em Python

    Crie um arquivo chamado deriv_bot_xauusd.py e cole o código abaixo:

    import requests
    import json
    import time
    import pandas as pd
    import numpy as np
    from datetime import datetime
    import websocket
    import threading
    import os
    from dotenv import load_dotenv
    
    # Carrega variáveis de ambiente (API_KEY e APP_ID)
    load_dotenv()
    
    # Configurações do robô
    API_TOKEN = os.getenv("DERIV_API_TOKEN")  # Substitua pelo seu token ou use .env
    APP_ID = os.getenv("DERIV_APP_ID")  # ID do seu app registrado na Deriv
    SYMBOL = "frxXAUUSD"  # XAUUSD (Ouro/Dólar)
    TIMEFRAME = 300  # 5 minutos em segundos
    STAKE = 0.35  # Valor inicial da aposta
    MARTINGALE_FACTOR = 1.20  # Fator de aumento após perda
    TAKE_PROFIT = 10.0  # Meta de lucro em USD
    STOP_LOSS = 20.0  # Limite de perda em USD
    SMA_FAST = 10  # Período da SMA rápida
    SMA_SLOW = 25  # Período da SMA lenta
    
    # Variáveis globais
    current_trend = None  # "alta" ou "baixa"
    current_stake = STAKE
    total_profit = 0.0
    total_loss = 0.0
    historical_data = pd.DataFrame(columns=['timestamp', 'close'])
    
    # Função para conectar à API da Deriv
    def get_deriv_api():
        url = "https://api.deriv.com/api/v1/authorize"
        headers = {"Content-Type": "application/json"}
        payload = {
            "authorize": {
                "app_id": APP_ID,
                "api_token": API_TOKEN
            }
        }
        response = requests.post(url, headers=headers, json=payload)
        return response.json()
    
    # Função para obter dados históricos
    def get_historical_data():
        url = "https://api.deriv.com/api/v1/ticks_history"
        params = {
            "ticks_history": SYMBOL,
            "end": "latest",
            "count": 1000,
            "granularity": TIMEFRAME,
            "style": "candles"
        }
        response = requests.get(url, params=params)
        return response.json()
    
    # Função para calcular SMAs
    def calculate_sma(data, period):
        return data['close'].rolling(window=period).mean().iloc[-1]
    
    # Função para verificar tendência
    def check_trend():
        global current_trend, historical_data
    
        # Obtém dados históricos
        data = get_historical_data()
        if 'error' in data:
            print("Erro ao obter dados históricos:", data['error']['message'])
            return None
    
        # Converte para DataFrame
        candles = data['candles']
        df = pd.DataFrame(candles, columns=['epoch', 'open', 'high', 'low', 'close'])
        df['timestamp'] = pd.to_datetime(df['epoch'], unit='s')
        df.set_index('timestamp', inplace=True)
    
        # Atualiza dados históricos
        historical_data = df
    
        # Calcula SMAs
        sma_fast = calculate_sma(df, SMA_FAST)
        sma_slow = calculate_sma(df, SMA_SLOW)
    
        # Determina a tendência atual
        if sma_fast > sma_slow:
            new_trend = "alta"
        else:
            new_trend = "baixa"
    
        # Verifica se houve virada de tendência
        if current_trend is None:
            current_trend = new_trend
            return None  # Primeira execução, ainda não há tendência anterior
    
        if new_trend != current_trend:
            trend_change = {
                "old_trend": current_trend,
                "new_trend": new_trend,
                "sma_fast": sma_fast,
                "sma_slow": sma_slow
            }
            current_trend = new_trend
            return trend_change
        else:
            return None
    
    # Função para comprar na Deriv
    def buy_contract(direction):
        global current_stake, total_profit, total_loss
    
        url = "https://api.deriv.com/api/v1/buy"
        headers = {"Content-Type": "application/json"}
        payload = {
            "buy": {
                "amount": current_stake,
                "basis": "stake",
                "contract_type": "CALL" if direction == "alta" else "PUT",
                "currency": "USD",
                "duration": TIMEFRAME,
                "duration_unit": "s",
                "symbol": SYMBOL
            }
        }
    
        response = requests.post(url, headers=headers, json=payload)
        contract = response.json()
    
        if 'error' in contract:
            print("Erro ao comprar contrato:", contract['error']['message'])
            return None
    
        print(f"Compra realizada: {direction}, Stake: ${current_stake:.2f}")
        return contract
    
    # Função para verificar resultado do contrato
    def check_contract_result(contract_id):
        url = "https://api.deriv.com/api/v1/portfolio"
        params = {"portfolio": 1, "contract_id": contract_id}
        response = requests.get(url, params=params)
        result = response.json()
    
        if 'error' in result:
            print("Erro ao verificar contrato:", result['error']['message'])
            return None
    
        contract = result['portfolio']['contracts'][0]
        profit = float(contract['profit'])
    
        if profit > 0:
            print(f"Resultado: GANHO! Lucro: ${profit:.2f}")
            return "win"
        else:
            print(f"Resultado: PERDA! Prejuízo: ${abs(profit):.2f}")
            return "loss"
    
    # Função principal do robô
    def run_bot():
        global current_stake, total_profit, total_loss
    
        print("Iniciando robô de trading para XAUUSD...")
    
        while True:
            try:
                # Verifica virada de tendência
                trend_change = check_trend()
    
                if trend_change:
                    print(f"Virada de tendência detectada: {trend_change['old_trend']} -> {trend_change['new_trend']}")
                    print(f"SMA Rápida: {trend_change['sma_fast']:.4f}, SMA Lenta: {trend_change['sma_slow']:.4f}")
    
                    # Compra na direção da nova tendência
                    contract = buy_contract(trend_change['new_trend'])
    
                    if contract:
                        contract_id = contract['buy']['contract_id']
                        time.sleep(TIMEFRAME + 10)  # Espera o contrato expirar
    
                        # Verifica resultado
                        result = check_contract_result(contract_id)
    
                        if result == "win":
                            total_profit += current_stake
                            current_stake = STAKE  # Reseta o stake após ganho
                            print(f"Lucro acumulado: ${total_profit:.2f}")
                        else:
                            total_loss += current_stake
                            current_stake *= MARTINGALE_FACTOR  # Aplica Martingale
                            print(f"Prejuízo acumulado: ${total_loss:.2f}")
    
                        # Verifica se atingiu Take Profit ou Stop Loss
                        if total_profit >= TAKE_PROFIT:
                            print("Meta de lucro atingida! Encerrando...")
                            break
                        elif total_loss >= STOP_LOSS:
                            print("Limite de perda atingido! Encerrando...")
                            break
    
                # Espera 5 minutos antes da próxima verificação
                time.sleep(TIMEFRAME)
    
            except Exception as e:
                print("Erro:", e)
                time.sleep(10)  # Espera 10 segundos antes de tentar novamente
    
    if __name__ == "__main__":
        run_bot()
    

    3. Como Usar o Robô

    Passo 1: Configurar API da Deriv

    1. Crie um arquivo .env na mesma pasta do script:
      DERIV_API_TOKEN=seu_token_aqui
      DERIV_APP_ID=seu_app_id_aqui
      
      • Obtenha seu API Token em Deriv API.
      • O App ID é gerado quando você registra um app na Deriv.

    Passo 2: Executar o Robô

    python deriv_bot_xauusd.py
    

    Passo 3: Monitorar o Robô

    • O robô imprimirá no console:
      • Viradas de tendência detectadas.
      • Compras realizadas.
      • Resultados (ganhos/perdas).
      • Lucro/prejuízo acumulado.

    4. Melhorias Possíveis

    1. Backtesting: Use dados históricos para testar a estratégia antes de operar com dinheiro real.
    2. Otimização de Parâmetros: Ajuste os períodos das SMAs (SMA_FAST e SMA_SLOW) para melhor desempenho.
    3. Gerenciamento de Risco: Adicione mais regras de stop loss ou take profit dinâmico.
    4. Notificações: Envie alertas por e-mail ou Telegram quando o robô fizer uma operação.

    5. Considerações Finais

    • Teste em Conta Demo: Sempre execute o robô em uma conta virtual antes de usar dinheiro real.
    • Risco do Martingale: O Martingale pode ser perigoso. Use com cautela e defina um stop loss rígido.
    • Ajustes Futuros: Você pode adicionar mais indicadores (RSI, MACD) para confirmar as viradas de tendência.

    Se precisar de ajustes ou explicações adicionais, é só avisar! 🚀

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.