Clientes WebSocket API para terminal/consola

El cliente API WebSocket para Kraken Futures permite acceso completo a la API de Futuros con WebSocket a través de la línea de comandos, por lo que no es necesario tener conocimientos o experiencia previa con API.

Todos los feeds de WebSocket son accesibles, incluyendo:

  • feeds públicos para datos de mercado
  • feeds privados para gestión de cuenta

El cliente de línea de comandos puede usarse como un cliente API independiente, o se puede llamar desde otros programas (como otros lenguajes interpretados como scripts Bash, o lenguajes compilados como C).

Instalación

1. Instale Python 2 (si es necesario).

  • MacOS y Linux probablemente ya tengan Python 2
  • Windows probablemente no lo tenga, pero puede ser instalado desde https://www.python.org/


2. Descargue el archivo krakenfuturesws.py a su computadora en la carpeta (directorio) de su elección.

  • Por ejemplo: Macintosh HD > Users > satoshi > KrakenFuturesWS


3. Abra una línea de comandos (como el Terminal de MacOS), y navegue a la carpeta (directorio) elegido en el paso anterior.

Puede utilizar el comando "cd" (Cambiar Directorio) para navegar. Por ejemplo:

cd /Users/satoshi/KrakenFuturesWS


4. Configure el archivo krakenfuturesws.py como ejecutable.

Puede utilizar el comando "chmod" (cambiar modo). Por ejemplo:

chmod 755 krakenfuturesws.py


5. Opcional: Agregue sus claves API al mismo directorio donde conserva el archivo krakenfuturesws.py.

Copie y pegue su clave pública API desde Configuración de la cuenta en un archivo llamado "API_Public".

Copie y pegue su clave privada API desde Configuración de la cuenta en un archivo llamado "API_Private".

Consulte: ¿Cómo generar un par de claves API válido?

Un par de claves API sólo es necesario si planea utilizar los feeds privados WebSocket para acceder su cuenta de Kraken Futures (como feeds de balance, feeds de órdenes y posiciones, notificaciones de cuenta, etc.).

Uso

El cliente WebSocket API para línea de comandos se usa escribiendo comandos como "./krakenfuturesws.py api_feed feed_parameters" en una consola/terminal. Por ejemplo:

./krakenfuturesws.py ticker_lite pi_xbtusd

./krakenfuturesws.py book pi_ethusd pi_ltcusd pi_bchusd

./krakenfuturesws.py account_balances_and_margins

./krakenfuturesws.py fills

./krakenfuturesws.py open_positions

Los detalles completos de todos los feeds WebSocket para Kraken Futures están disponibles a través de la Documentación de la API.

Código Python 2

Puede descargar el cliente API WebSocket para línea de comandos en la sección anterior de Instalación.

Para referencia, el código Python 2 para el cliente API se muestra a continuación:

#!/usr/bin/env python
        
        # Kraken Futures WebSocket API
        # 
        # Usage: ./krakenfuturesws feed parameters
        # Example: ./krakenfuturesws ticker_lite pi_xbtusd
        # Example: ./krakenfuturesws book pi_xbtusd pi_ethusd
        # Example: ./krakenfuturesws account_balances_and_margins
        # Example: ./krakenfuturesws fills
        # 
        # For private feeds (anything accessing an account), API public key and API private key must be in separate text files called API_Public and API_Private respectively.
        
        import sys
        import base64
        import hashlib
        import hmac
        import json
        from websocket import create_connection
        
        api_public = {"trade", "book", "ticker", "ticker_lite"}
        api_private = {"account_balances_and_margins", "account_log", "deposits_withdrawals", "fills", "open_positions", "open_orders", "open_orders_verbose", "notifications_auth"}
        api_domain = "wss://futures.kraken.com/ws/v1"
        
        if len(sys.argv) < 2:
            print("Usage: {} feed parameters".format(sys.argv[0]))
            print("Example: {} ticker_lite pi_xbtusd".format(sys.argv[0]))
            sys.exit(1)
        
        try:
            ws = create_connection(api_domain)
            print(ws.recv())
            ws.send('{"event":"subscribe", "feed":"heartbeat"}')
            print(ws.recv())
        except Exception as error:
            print("WebSocket connection failed due to unexpected error (%s)" % error)
            sys.exit(1)
        
        api_feed = sys.argv[1]
        
        if api_feed in api_public:
            if len(sys.argv) < 3:
                print("Usage: {} feed parameters".format(sys.argv[0]))
                print("Example: {} ticker_lite pi_xbtusd".format(sys.argv[0]))
                ws.close()
                sys.exit(1)
            api_symbols = sys.argv[2]
            for count in range(3, len(sys.argv)):
                api_symbols = api_symbols + '","' + sys.argv[count]
            api_data = '{"event":"subscribe", "feed":"%(feed)s", "product_ids":["%(symbols)s"]}' % {"feed":api_feed, "symbols":api_symbols}
        elif api_feed in api_private:
            try:
                api_key = open("API_Public").read().strip()
                api_secret = base64.b64decode(open("API_Private").read().strip())
            except:
                print("API public key and API private key must be in text files called API_Public and API_Private")
                ws.close()
                sys.exit(1)
            api_data = '{"event":"challenge", "api_key":"%s"}' % api_key
            try:
                ws.send(api_data)
                api_data = ws.recv()
            except Exception as error:
                print("WebSocket authentication failed due to unexpected error (%s)" % error)
                ws.close()
                sys.exit(1)
            api_challenge = str(json.loads(api_data)["message"])
            api_sha256 = hashlib.sha256(api_challenge).digest()
            api_hmacsha512 = hmac.new(api_secret, api_sha256, hashlib.sha512)
            api_signature = base64.b64encode(api_hmacsha512.digest())
            api_data = '{"event":"subscribe", "feed":"%(feed)s", "api_key":"%(key)s", "original_challenge":"%(challenge)s", "signed_challenge":"%(signature)s"}' % {"feed":api_feed, "key":api_key, "challenge":api_challenge, "signature":api_signature}
        else:
            print("Usage: {} feed parameters".format(sys.argv[0]))
            print("Example: {} ticker_lite pi_xbtusd".format(sys.argv[0]))
            ws.close()
            sys.exit(1)
        
        try:
            ws.send(api_data)
        except Exception as error:
            print("Subscription to %(feed)s feed failed due to unexpected error (%(error))" % {"feed":sys.argv[1], "error":error})
            ws.close()
            sys.exit(1)
        
        for count in range(300):
            try:
                api_data = ws.recv()
                print(api_data)
            except KeyboardInterrupt:
                ws.close()
                sys.exit(1)
        
        ws.close()
        sys.exit(0)