Código de exemplo para interpretar o feed do livro de ordens da WebSocket API v1 (assíncrono/multithread)

Última atualização: 2 de abr. de 2025

Instruções detalhadas para interpretar o feed do livro de ordens da WebSocket API v1 estão disponíveis em nossa página de suporte Como manter um livro de ordens válido.

Um código de exemplo em Python para integração com o feed do livro de ordens da WebSocket API v1 e para manter uma cópia local de um livro de ordens é fornecido abaixo.

O código usa a biblioteca Python WebSocket padrão e implementa uma abordagem assíncrona (orientada a eventos/multithread), que permite que outras tarefas continuem em paralelo à interpretação do feed do livro de ordens.

Uso

O código deve ser executado via prompt de comando (como o Terminal do macOS) da seguinte forma:

  • •

    krakenwsorderbookasync.py símbolo profundidade, ou,

  • •

    python3 krakenwsorderbookasync.py símbolo profundidade

Por exemplo, o seguinte comando recuperaria e interpretaria o feed do livro de ordens Dogecoin/USD (XDG/USD) com uma profundidade de 10 níveis de preço (por lado):

  • •

    krakenwsorderbookasync.py XDG/USD 10

Observe que o código será executado indefinidamente até ser encerrado por uma interrupção do teclado (Ctrl+C na maioria dos ambientes de linha de comando).

Código Python

O código Python pode ser visualizado abaixo e também pode ser baixado como krakenwsorderbookasync.py.

#!/usr/bin/env python3

# Import WebSocket client library (and others)
import sys
import json
import signal
import time
import _thread
import websocket

# Parse command line arguments (symbol and depth)
if len(sys.argv) < 3:
sys.exit(1)
else:
api_symbol = sys.argv[1]
api_depth = int(sys.argv[2])

# Define order book variables
api_book = {'bid':{}, 'ask':{}}

# Define order book update functions
def dicttofloat(data):
return float(data[0])

def api_book_update(api_book_side, api_book_data):
for data in api_book_data:
price_level = data[0]
volume = data[1]
if float(volume) > 0.0:
api_book[api_book_side][price_level] = volume
else:
api_book[api_book_side].pop(price_level)
if api_book_side == 'bid':
api_book['bid'] = dict(sorted(api_book['bid'].items(), key=dicttofloat, reverse=True)[:api_depth])
elif api_book_side == 'ask':
api_book['ask'] = dict(sorted(api_book['ask'].items(), key=dicttofloat)[:api_depth])

# Define WebSocket callback functions
def ws_thread(*args):
ws = websocket.WebSocketApp('wss://ws.kraken.com/', on_open=ws_open, on_message=ws_message)
ws.run_forever()

def ws_open(ws):
ws.send('{"event":"subscribe", "subscription":{"name":"book", "depth":%(api_depth)d}, "pair":["%(api_symbol)s"]}' % {'api_depth':api_depth, 'api_symbol':api_symbol})

def ws_message(ws, ws_data):
api_data = json.loads(ws_data)
if 'event' in api_data:
return
else:
if 'as' in api_data[1]:
api_book_update('ask', api_data[1]['as'])
api_book_update('bid', api_data[1]['bs'])
else:
for data in api_data[1:len(api_data)-2]:
if 'a' in data:
api_book_update('ask', data['a'])
elif 'b' in data:
api_book_update('bid', data['b'])

# Start new thread for WebSocket interface
_thread.start_new_thread(ws_thread, ())

# Output order book (once per second) in main thread
try:
while True:
if len(api_book['bid']) < api_depth or len(api_book['ask']) < api_depth:
time.sleep(1)
else:
bid = sorted(api_book['bid'].items(), key=dicttofloat, reverse=True)
ask = sorted(api_book['ask'].items(), key=dicttofloat)
print('Bid\t\t\t\t\t\t\tAsk')
for count in range(api_depth):
print('%(bidprice)s (%(bidvolume)s)\t\t\t\t%(askprice)s (%(askvolume)s)' \
% {'bidprice':bid[count][0], 'bidvolume':bid[count][1], 'askprice':ask[count][0], 'askvolume':ask[count][1]})
time.sleep(1)
except KeyboardInterrupt:
sys.exit(0)

Precisa de mais ajuda?