Futures Websockets

class kraken.futures.FuturesWSClient(key: str = '', secret: str = '', url: str = '', callback: Callable | None = None, *, sandbox: bool = False)

Bases: FuturesAsyncClient

Class to access public and (optional) private/authenticated websocket connection.

So far there are no trade endpoints that can be accessed using the Futures Kraken API. If this has changed and is not implemented yet, please open an issue at https://github.com/btschwertfeger/python-kraken-sdk/issues

https://docs.kraken.com/api/docs/guides/futures-websockets

Parameters:

key (str, optional) – The Kraken Futures API key to access private endpoints
secret (str, optional) – The Kraken Futures Secret key to access private endpoints
url (str, optional) – Set a custom URL (default: futures.kraken.com/ws/v1)
sandbox (bool, optional) – Use the Kraken Futures demo environment (URL will switch to demo-futures.kraken.com/ws/v1, default: False)

Futures Websocket: Create the websocket client

import asyncio
from kraken.futures import FuturesWSClient

# Create the custom client
class Client(FuturesWSClient):
    async def on_message(self, event: dict) -> None:
        print(event)

async def main() -> None:
    client = Client()     # unauthenticated
    auth_client = Client( # authenticated
        key="api-key",
        secret="secret-key"
    )

    # open the websocket connections
    await client.start()
    await auth_client.start()

    # now you can subscribe to channels using
    await client.subscribe(
        feed='ticker',
        products=["XBTUSD", "DOT/EUR"]
    )
    # the messages can be used within the `on_message` callback method

    while True:
        await asyncio.sleep(6)

if __name__ == "__main__":
    try:
        asyncio.run(main())
    except KeyboardInterrupt:
        pass

Futures Websocket: Create the websocket client as context manager

import asyncio
from kraken.futures import FuturesWSClient

async def on_message(message):
    print(message)

async def main() -> None:
    async with FuturesWSClient(callback=on_message) as session:
        await session.subscribe(feed="ticker", products=["PF_XBTUSD"])

    while True:
        await asyncio.sleep(6)

if __name__ == "__main__":
    try:
        asyncio.run(main())
    except KeyboardInterrupt:
        pass

async_close() → None: Closes the aiohttp session

async close() → None: Method to stop the websocket connection.

property exception_occur: bool: Returns True if the connection was stopped due to an exception.

get_active_subscriptions() → list[dict]

Returns the list of active subscriptions.

Returns:: List of active subscriptions including the feed names, products and additional information.
Return type:: list[dict]

Initialize your client as described in kraken.futures.FuturesWSClient to run the following example:

Futures Websocket: Get the active subscriptions

>>> from kraken.futures import FuturesWSClient
...
>>> FuturesWSClient.get_active_subscriptions()
[
    {
        "event": "subscribe",
        "feed": "ticker,
        "product_ids": ["PI_XBTUSD"]
    }, {
        "event": "subscribe",
        "feed": "open_orders,
    }, ...
]

static get_available_private_subscription_feeds() → list[str]

Return all available private feeds that can be un-/subscribed to/from using the Kraken Futures API

Returns:: List of available private feeds
Return type:: list[str]

Futures Websocket: Get the available private subscription feeds

>>> from kraken.futures import FuturesWSClient
>>> FuturesWSClient.get_available_private_subscription_feeds()
[
    "fills", "open_positions", "open_orders",
    "open_orders_verbose", "balances",
    "deposits_withdrawals", "account_balances_and_margins",
    "account_log", "notifications_auth"
]

static get_available_public_subscription_feeds() → list[str]

Return all available public feeds that can be un-/subscribed using the Kraken Futures API.

Returns:: List of available public feeds
Return type:: list[str]

Futures Websocket: Get the available public subscription feeds

>>> from kraken.futures import FuturesWSClient
>>> FuturesWSClient.get_available_private_subscription_feeds()
[
    "trade", "book", "ticker",
    "ticker_lite", "heartbeat"
]

get_nonce() → str: Return a new nonce

get_sign_challenge(challenge: str) → str

Sign the challenge/message using the secret key

Parameters:: challenge (str) – The challenge/message to sign
Returns:: The signed message
Raises:: kraken.exceptions.KrakenAuthenticationError – If the credentials are not valid
Return type:: str

property is_auth: bool

Checks if key and secret are set.

Returns:: True if the credentials are set, else False
Return type:: bool

Futures Websocket: Check if the credentials are set

>>> from kraken.futures import FuturesWSClient
>>> FuturesWSClient().is_auth()
False

property key: str: Returns the API key

async on_message(message: dict) → None

Method that serves as the default callback function Calls the defined callback function (if defined) or overload this function.

This is the default method which just logs the messages. In production you want to overload this with your custom methods, as shown in the Example of kraken.futures.FuturesWSClient.

Parameters:: message (dict) – The message that was send by Kraken via the websocket connection.
Return type:: None

Handles the requested requests, by sending the request, handling the response, and returning the message or in case of an error the respective Exception.

Parameters:

method (str) – The request method, e.g., GET, POST, and PUT
uri (str) – The endpoint to send the message
post_params (dict, optional) – The query parameter of the request (default: None)
extra_params (str | dict, optional) – Additional query parameter of the request (default: None)
query_params (dict, optional) – The query parameter of the request (default: None)
timeout (int) – Timeout for the request (default: 10)
auth (bool) – If the request needs authentication (default: True)
return_raw (bool, optional) – If the response should be returned without parsing. This is used for example when requesting an export of the trade history as .zip archive.

Raises:

kraken.exceptions.* – If the response contains errors

Returns:

The response

Return type:

dict | list | requests.Response

async start() → None: Method to start the websocket connection.

stop() → None: Method to stop the websocket connection.

async subscribe(feed: str, products: list[str] | None = None) → None

Subscribe to a Futures websocket channel/feed. For some feeds authentication is required.

https://docs.kraken.com/api/docs/guides/futures-websockets

Parameters:

feed (str) – The websocket feed/channel to subscribe to
products (list[str], optional) – The products/futures contracts to subscribe to

Raises:

TypeError – If the parameters don’t match the requirements set by the Kraken API

Initialize your client as described in kraken.futures.FuturesWSClient to run the following example:

Futures Websocket: Subscribe to a feed

>>> await bot.subscribe(feed='ticker', products=["XBTUSD", "DOT/EUR"])

Success or failures are sent over the websocket connection and can be received via the default kraken.futures.FuturesWSClient.on_message() or a custom callback function.

async unsubscribe(feed: str, products: list[str] | None = None) → None

Subscribe to a Futures websocket channel/feed. For some feeds authentication is required.

https://docs.kraken.com/api/docs/guides/futures-websockets

Parameters:

feed (str) – The websocket feed/channel to unsubscribe from
products (list[str], optional) – The products/futures contracts to unsubscribe from

Raises:

TypeError – If the parameters don’t match the requirements set by the Kraken API

Initialize your client as described in kraken.futures.FuturesWSClient to run the following example:

Futures Websocket: Unsubscribe from a feed

>>> await bot.unsubscribe(feed='ticker', products=["XBTUSD", "DOT/EUR"])

Success or failures are sent over the websocket connection and can be received via the default kraken.futures.FuturesWSClient.on_message`() or a custom callback function.