Futures Websockets

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

Bases: KrakenFuturesBaseAPI

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.futures.kraken.com/#websocket-api

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 KrakenFuturesWSClient

async def main() -> None:

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

    client = Client()     # unauthenticated
    auth_client = Client( # authenticated
        key="api-key",
        secret="secret-key"
    )

    # 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 KrakenFuturesWSClient

async def on_messageessage):
    print(message)

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

    while True:
        await asyncio.sleep(6)

if __name__ == "__main__":
    loop = asyncio.new_event_loop()
    asyncio.set_event_loop(loop)
    try:
        asyncio.run(main())
    except KeyboardInterrupt:
        pass
    finally:
        loop.close()

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.KrakenFuturesWSClient to run the following example:

Futures Websocket: Get the active subscriptions

>>> from kraken.futures import KrakenFuturesWSClient
...
>>> KrakenFuturesWSClient.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 KrakenFuturesWSClient
>>> KrakenFuturesWSClient.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 KrakenFuturesWSClient
>>> KrakenFuturesWSClient.get_available_private_subscription_feeds()
[
    "trade", "book", "ticker",
    "ticker_lite", "heartbeat"
]

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 KrakenFuturesWSClient
>>> KrakenFuturesWSClient().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.KrakenFuturesWSClient.

Parameters:

message (dict) – The message that was send by Kraken via the websocket connection.

Return type:

None

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.futures.kraken.com/#websocket-api-websocket-api-introduction-subscriptions

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.KrakenFuturesWSClient 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.KrakenFuturesWSClient.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.futures.kraken.com/#websocket-api-websocket-api-introduction-subscriptions

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.KrakenFuturesWSClient 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.KrakenFuturesWSClient.on_message`() or a custom callback function.