Como transformar trades em tempo real em insights de fluxo de mercado.
Os trades não mentem
Quem está agredindo o livro, em que volume e com que frequência? Essa informação não está em um indicador derivado, está no dado bruto, no tick a tick. Cada negócio executado carrega o agente comprador, o agente vendedor e o tipo de agressão. A análise de players é justamente a leitura desse fluxo: identificar quem domina o mercado, de que lado e em que momento.
É um diferencial competitivo porque a maioria das ferramentas mostra apenas preço e volume agregado. Poucas mostram quem está por trás do movimento. Com a ProfitDLL, você captura o fluxo bruto e constrói exatamente a visualização que a sua estratégia precisa, do seu jeito.
Este artigo mostra o que é possível construir e entrega um ponto de partida concreto: um kernel em Python funcional que conecta, recebe trades e agrega o fluxo por player. A partir dele, a visualização fica a seu critério.
O que você consegue construir
Esse é o tipo de painel que sua aplicação pode entregar — alimentado inteiramente pelo callback de trade da ProfitDLL:
Os widgets que o mockup mostra, todos construíveis com o que vem a seguir:
- Ranking de agentes do dia — top compradores e top vendedores por volume
- Saldo de agressão por player — quem puxou o mercado, e para que lado
- Times & Trades em tempo real — a lista rolante de negócios, tick a tick
- Heat map de atividade por horário — quando cada player foi mais ativo
- Comparativo de volume vs. média histórica — o fluxo de hoje contra o padrão
Nada disso exige uma infraestrutura pesada. Tudo nasce de uma assinatura e de um callback — e é exatamente isso que as próximas seções cobrem.
Os ingredientes que a DLL te dá
O que chega no callback de trade é praticamente um raio-X do mercado. Três fontes de dado sustentam qualquer dashboard de player flow.
Trades em tempo real com identificação do agente
Cada negócio executado dispara o TConnectorTradeCallback, registrado via SetTradeCallbackV2 após uma assinatura com SubscribeTicker. A estrutura TConnectorTrade traz os campos que importam para a análise de players:
- BuyAgent e SellAgent — os agentes (corretoras) dos dois lados
- TradeType — o tipo do negócio, incluindo agressão de compra e agressão de venda
- Quantity e Price — volume e preço
- TradeDate — horário com precisão de milissegundo
Saber quem agrediu e em que volume é a matéria-prima do saldo de agressão. Os detalhes de subscription e callback estão em Funções Real Time - DLL.
Histórico tick a tick
O mesmo formato de trade está disponível para pregões passados. Isso permite reconstruir sessões anteriores e fazer análise comparativa — o ranking de hoje contra a média dos últimos pregões, ou o estudo do comportamento histórico de um player específico. Veja Como requisitar trades históricos com a ProfitDLL.
Livro de ofertas individual
O callback de trade mostra quem agrediu. O livro de ofertas mostra quem está posicionado — cada oferta individual, com seu agente, quantidade e preço. Assinado com SubscribeOfferBook (callback TOfferBookCallbackV2), ele permite reconstruir os agentes em cada nível de preço e ver intenção, não só execução. Detalhes em Funções Real Time - DLL.
O kernel da solução
O coração de qualquer dashboard de player flow é um pipeline simples: assinar, agregar, exibir.
O callback recebe cada trade e apenas o enfileira. Uma thread separada consome a fila e agrega as estatísticas por agente. A visualização lê o resultado agregado. Esse desenho mantém o callback rápido — ponto crítico, porque ele roda na thread interna da DLL.
Veja o esqueleto. Ele conecta, recebe trades e mantém o saldo de agressão por agente:
from ctypes import WINFUNCTYPE, POINTER, WinDLL, byref, c_int, c_uint, c_size_t
from profitTypes import TConnectorAssetIdentifier, TConnectorTrade
from queue import Queue
import threading
fila_de_trades: Queue = Queue() # ponte entre o callback e o consumer
_callbacks: list = [] # mantem as referencias vivas (anti-GC)
# stdcall -> WinDLL (CDLL corromperia a pilha silenciosamente)
dll = WinDLL(r"C:\ProfitDLL\Win64\ProfitDLL.dll")
dll.TranslateTrade.argtypes = [c_size_t, POINTER(TConnectorTrade)]
dll.TranslateTrade.restype = c_int
# Callback de trade V2: o ativo chega POR VALOR; o trade vem como um
# ponteiro opaco (c_size_t) e e' extraido com TranslateTrade.
TradeCallback = WINFUNCTYPE(None, TConnectorAssetIdentifier, c_size_t, c_uint)
def on_trade(asset, p_trade, flags):
trade = TConnectorTrade()
trade.Version = 0
if dll.TranslateTrade(p_trade, byref(trade)) == 0:
# O callback so' enfileira — a agregacao fica no consumer.
fila_de_trades.put((trade.BuyAgent, trade.SellAgent,
trade.Quantity, trade.TradeType))
cb_trade = TradeCallback(on_trade)
_callbacks.append(cb_trade)
# Apos DLLInitializeMarketLogin(...): registra o callback e assina o ativo.
# dll.SetTradeCallbackV2(cb_trade)
# dll.SubscribeTicker("WDOFUT", "F")
# Consumer: roda em outra thread, agrega o saldo de agressao por agente.
saldo_de_agressao: dict[int, int] = {}
def consumir():
while True:
buy_agent, sell_agent, qtd, trade_type = fila_de_trades.get()
if trade_type == 2: # agressao de compra
saldo_de_agressao[buy_agent] = saldo_de_agressao.get(buy_agent, 0) + qtd
elif trade_type == 3: # agressao de venda
saldo_de_agressao[sell_agent] = saldo_de_agressao.get(sell_agent, 0) - qtd
threading.Thread(target=consumir, daemon=True).start()
Três pontos do código merecem atenção — são erros que travam de forma silenciosa:
- Quantity é Int64.** Em Python, use c_longlong/c_int64. Em Windows x64, c_long tem só 32 bits e trunca sem avisar. O mesmo vale para qualquer campo Int64 da DLL.
- TConnectorAssetIdentifier chega por valor** nos callbacks modernos. Declare a struct direto no WINFUNCTYPE, nunca POINTER.
- A referência do callback precisa ficar viva. Guardada numa lista (ou atributo/global), nunca numa variável local. Se o garbage collector a liberar, a DLL chama um ponteiro inválido e o processo trava.
Imprimindo o ranking a cada poucos segundos, o resultado é direto:
[10:21:06] Ranking de players — WDOFUT — Top 10 por saldo de agressao
Agente Vol Comprado Vol Vendido Saldo Agressao
------------------------------------------------------------
39 133 542 -505
23 0 155 -155
3 488 402 -130
1618 148 26 +75
85 268 102 +67 O exemplo completo — distribuído em quatro arquivos (config.py, profit_dll_init.py, player_aggregator.py, dashboard_kernel.py), sem nenhuma dependência externa além da própria DLL — expande esse esqueleto com tratamento de conexão, agregação completa de volume comprado/vendido e encerramento limpo.
Importante: o exemplo completo está disponível em anexo neste artigo.
Caminhos para a visualização
Com o kernel rodando, a visualização é uma escolha de stack — não há um caminho único. O dicionário agregado em memória é a fonte; qualquer camada de exibição lê dele.
- Web (Flask + Plotly ou Chart.js) — bom para dashboards acessíveis remotamente e fáceis de compartilhar com uma equipe.
- Desktop (Tkinter, PyQt ou Electron) — bom para aplicações locais, com baixa latência visual e sem depender de navegador.
- Notebook + Streamlit — bom para exploração rápida e prototipagem: você itera na análise sem montar uma aplicação.
- Excel via xlwings + COM — o caminho menos óbvio, mas útil para quem já trabalha com planilhas e quer o fluxo ao vivo dentro delas.
A escolha depende de onde o dashboard vai viver e de quem vai usá-lo. O kernel não muda.
Casos de uso reais
O mesmo kernel — assinar, agregar, exibir — sustenta análises bem diferentes:
- Identificação de players grandes do dia. Ordene o ranking por volume e veja, em tempo real, quais agentes dominaram o fluxo do pregão.
- Detecção de mudança de comportamento. Um agente que era consistentemente comprador começa a aparecer do lado vendedor — o saldo de agressão inverte, e o seu painel mostra isso na hora.
- Análise de fluxo direcional. Acumule o saldo de agressão ao longo do dia e correlacione com o preço: divergências entre fluxo e preço são sinais que muitos indicadores não capturam.
- Comparativos históricos. Com trades históricos, compare o ranking de hoje com a média dos últimos pregões e destaque quando um player está anormalmente ativo.
Próximos passos
Com o kernel rodando, aprofunde em cada peça da trilha técnica:
- Ecossistema ProfitDLL e primeiros passos — inicialização, conexão e o modelo de callbacks.
- Funções Real Time - DLL — todas as subscriptions de tempo real e seus callbacks.
- Como requisitar trades históricos com a ProfitDLL — base para os comparativos históricos.
- Como utilizar o Livro de Profundidade (Price Depth) via DLL Real Time — visão complementar por nível de preço.
- Como rotear ordens com a ProfitDLL — quando quiser agir sobre os insights que o dashboard revelar.
Para mais informações, encaminhe um e-mail para corporativo@nelogica.com.br.
Achou útil este conteúdo?
Não esqueça de nos avaliar abaixo.
Desejamos bons trades!