A API oficial da Deriv permite negociar de forma programática via WebSocket, e o fluxo essencial de qualquer contrato gira em torno de três etapas: pedir um preço (proposal), comprar (buy) e acompanhar o resultado (proposal_open_contract). Este guia mostra, com código Python real e comentado, como encadear essas chamadas corretamente — incluindo os erros mais comuns que travam iniciantes. É uma referência técnica honesta: a API é poderosa, mas automatizar não significa lucrar.

Quer um bot pronto em Python conectado à API da Deriv para estudar o código?

Ver bot e API Python para Deriv →

Comece sempre por uma conta demo (token virtual).

Visão geral do fluxo

A API da Deriv é baseada em WebSocket: você abre uma conexão, autentica com um token de API e troca mensagens JSON. Para executar uma operação você normalmente segue esta sequência:

1. authorize -> autentica a sessão com seu token 2. proposal -> pede o preço/payout do contrato desejado 3. buy -> compra usando o id retornado pela proposal 4. proposal_open_contract -> acompanha o contrato até o fim
Importante: use sempre o endpoint com o seu app_id. Gere um token em API Token nas configurações da conta e comece com um token de conta demo. Nunca exponha o token em código público ou repositórios.

1. Conexão e authorize

Usando a biblioteca websockets com asyncio, a base da conexão fica assim:

import asyncio, json, websockets APP_ID = “1089” # use seu proprio app_id TOKEN = “SEU_TOKEN_DEMO” # token de conta DEMO URL = f”wss://ws.derivws.com/websockets/v3?app_id={APP_ID}” async def chamar(ws, payload): await ws.send(json.dumps(payload)) return json.loads(await ws.recv()) async def main(): async with websockets.connect(URL) as ws: auth = await chamar(ws, {“authorize”: TOKEN}) if auth.get(“error”): print(“Erro auth:”, auth[“error”][“message”]); return print(“Conta:”, auth[“authorize”][“loginid”])

2. proposal — pedindo o preço

A proposal não compra nada: ela devolve o preço de entrada (ask_price), o payout e um id temporário que você usa para comprar. Exemplo de um contrato CALL de 60 segundos em um índice sintético:

proposta = await chamar(ws, { “proposal”: 1, “amount”: 1, # valor (stake) “basis”: “stake”, “contract_type”: “CALL”, “currency”: “USD”, “duration”: 60, “duration_unit”: “s”, “symbol”: “R_100” # indice sintetico Volatility 100 }) if proposta.get(“error”): print(“Erro proposal:”, proposta[“error”][“message”]); return prop_id = proposta[“proposal”][“id”] preco = proposta[“proposal”][“ask_price”] payout = proposta[“proposal”][“payout”] print(f”Payout: {payout} | Preco: {preco}”)
Atenção ao tempo de vida do id: o id da proposal expira em segundos. Se você demorar entre o proposal e o buy, receberá um erro e precisará pedir uma nova proposta.

3. buy — executando a compra

Com o id em mãos, a compra usa o parâmetro price como teto máximo que você aceita pagar (proteção contra slippage):

compra = await chamar(ws, { “buy”: prop_id, “price”: preco # preco maximo aceito }) if compra.get(“error”): print(“Erro buy:”, compra[“error”][“message”]); return contract_id = compra[“buy”][“contract_id”] print(“Comprado! contract_id:”, contract_id)

4. Acompanhar o resultado

Para saber se ganhou ou perdeu, assine atualizações do contrato com proposal_open_contract e subscribe: 1. A Deriv envia mensagens até o contrato encerrar (is_sold = 1), com o profit final:

await ws.send(json.dumps({ “proposal_open_contract”: 1, “contract_id”: contract_id, “subscribe”: 1 })) while True: msg = json.loads(await ws.recv()) poc = msg.get(“proposal_open_contract”) if not poc: continue if poc.get(“is_sold”): lucro = poc[“profit”] status = “GANHOU” if lucro > 0 else “PERDEU” print(f”Resultado: {status} | Lucro: {lucro}”) break asyncio.run(main())
Boa prática: trate sempre o campo error em toda resposta, controle o req_id quando enviar várias chamadas em paralelo, e respeite os limites de requisição da API para não tomar bloqueio temporário.

Erros comuns ao integrar

Os tropeços mais frequentes são: usar token de conta real por engano (teste sempre em demo primeiro), deixar o id da proposal expirar antes do buy, esquecer de tratar reconexões quando o WebSocket cai, e assumir que “automatizou, então vai lucrar”. A API apenas executa ordens; a lógica de decisão e a gestão de risco continuam sendo responsabilidade sua — e são elas que determinam o resultado.

Perguntas frequentes (FAQ)

A API da Deriv é oficial e gratuita?

Sim, a Deriv oferece uma API oficial e documentada via WebSocket, com tokens gerados pela própria conta. O uso da API em si não tem custo; você paga apenas o valor das operações que escolher fazer.

Preciso saber programar para usar?

Para a API direta em Python, sim — conhecimento básico de Python e asyncio ajuda muito. Quem não programa pode usar o criador de bots visual da própria Deriv (DBot) como alternativa.

Posso testar sem arriscar dinheiro?

Sim. Gere um token de conta demo e todo o fluxo (proposal, buy, resultado) funciona com saldo virtual. É exatamente assim que você deve começar.

Um bot conectado à API garante lucro?

Não. A automação só executa regras com disciplina. Se a estratégia não tem vantagem estatística, o bot apenas perderá de forma mais consistente. Não existe lucro garantido.

Aviso: opções binárias e índices sintéticos são produtos de altíssimo risco e a maioria dos investidores de varejo perde dinheiro. Este conteúdo é educacional e técnico, não constitui recomendação de investimento nem promessa de retorno. Os exemplos de código são para fins de estudo e podem exigir adaptação conforme a documentação atual da Deriv. Teste sempre em conta demo antes de qualquer valor real e nunca opere com dinheiro que você não pode perder.