Python Kraken Sdk

3. Start using the provided example scripts

4. Error handling

If any unexpected behavior occurs, please check your API permissions, rate limits, update the python-kraken-sdk, see the [Troubleshooting](#trouble) section, and if the error persists please open an issue.

📍 Command-line interface

The python-kraken-sdk provides a command-line interface to access the Kraken API using basic instructions while performing authentication tasks in the background. The Spot and Futures API are accessible and follow the pattern kraken {spot,futures} [OPTIONS] URL. See examples below.

# get server time
kraken spot https://api.kraken.com/0/public/Time
{'unixtime': 1716707589, 'rfc1123': 'Sun, 26 May 24 07:13:09 +0000'}

# get user's balances
kraken spot --api-key= --secret-key= -X POST https://api.kraken.com/0/private/Balance
{'ATOM': '17.28229999', 'BCH': '0.0000077100', 'ZUSD': '1000.0000'}

# get user's trade balances
kraken spot --api-key= --secret-key= -X POST https://api.kraken.com/0/private/TradeBalance --data '{"asset": "DOT"}'
{'eb': '2.8987347115', 'tb': '1.1694303513', 'm': '0.0000000000', 'uv': '0', 'n': '0.0000000000', 'c': '0.0000000000', 'v': '0.0000000000', 'e': '1.1694303513', 'mf': '1.1694303513'}

# get 1D candles for a futures instrument
kraken futures https://futures.kraken.com/api/charts/v1/spot/PI_XBTUSD/1d
{'candles': [{'time': 1625616000000, 'open': '34557.84000000000', 'high': '34803.20000000000', 'low': '33816.32000000000', 'close': '33880.22000000000', 'volume': '0' ...

# get user's open futures positions
kraken futures --api-key= --secret-key= https://futures.kraken.com/derivatives/api/v3/openpositions
{'result': 'success', 'openPositions': [], 'serverTime': '2024-05-26T07:15:38.91Z'}

... All endpoints of the Kraken Spot and Futurs API can be accessed like that.

📍 MCP Server

The python-kraken-sdk also ships an MCP server exposing the Spot (incl. xStocks — pass "asset_class": "tokenized_asset" inside params where the Kraken API docs require it) and Futures request methods as two tools, spot_request and futures_request.

uv tool install "python-kraken-sdk[mcp]"

# e.g. Claude setup:
claude mcp add kraken --scope user -- kraken-mcp

Credentials are never tool arguments. Configure them as environment variables instead: KRAKEN_SPOT_API_KEY / KRAKEN_SPOT_SECRET_KEY, KRAKEN_FUTURES_API_KEY / KRAKEN_FUTURES_SECRET_KEY, and optionally KRAKEN_FUTURES_SANDBOX=1 to target the Futures demo environment. Example client for Claude Code configuration:

// ~/.claude.json
{
  "mcpServers": {
    "kraken": {
      "command": "kraken-mcp",
      "env": {
        // Only public endpoints are available without credentials
        "KRAKEN_SPOT_API_KEY": "",
        "KRAKEN_SPOT_SECRET_KEY": ""
      }
    }
  }
}

📍 Spot Clients

The python-kraken-sdk provides lots of functions to easily access most of the REST and websocket endpoints of the Kraken Crypto Asset Exchange API. Since these endpoints and their parameters may change, all implemented endpoints are tested on a regular basis.

The Kraken Spot API can be accessed by executing requests to the endpoints directly using the request method provided by any client. This is demonstrated below.

See https://docs.kraken.com/api/docs/guides/global-intro for information about the available endpoints and their usage.

SpotClient

The Spot client provides access to all un-and authenticated endpoints of Kraken's Spot API.

from kraken.spot import SpotClient

client = SpotClient(key="", secret="")
print(client.request("POST", "/0/private/Balance"))

SpotAsyncClient

The async Spot client allows for asynchronous access to Kraken's Spot API endpoints. Below are two examples demonstrating its usage.

Using SpotAsyncClient without a context manager; In this example, the client is manually closed after the request is made.

import asyncio
from kraken.spot import SpotAsyncClient

async def main():
    client = SpotAsyncClient(key="", secret="")
    try:
        response = await client.request("POST", "/0/private/Balance")
        print(response)
    finally:
        await client.close()

if __name__ == "__main__":
    asyncio.run(main())

Using SpotAsyncClient as a context manager; This example demonstrates the use of the context manager, which ensures the client is automatically closed after the request is completed.

import asyncio
from kraken.spot import SpotAsyncClient

async def main():
    async with SpotAsyncClient(key="", secret="") as client:
        response = await client.request("POST", "/0/private/Balance")
        print(response)

if __name__ == "__main__":
    asyncio.run(main())

SpotWSClient (Websocket API)

Kraken offers two versions of their websocket API (V1 and V2). Since V2 is offers more possibilities, is way faster and easier to use, only the never version is supported by this SDK.

The official documentation for can be found at:

• https://docs.kraken.com/api/docs/guides/global-intro
• https://docs.kraken.com/websockets-v2

Note that authenticated Spot websocket clients can also un-/subscribe from/to public feeds.

The example below can be found in an extended way in examples/spot_ws_examples.py.

import asyncio
from kraken.spot import SpotWSClient

class Client(SpotWSClient):
    """Can be used to create a custom trading strategy"""

    async def on_message(self, message):
        """Receives the websocket messages"""
        if message.get("method") == "pong" \
            or message.get("channel") == "heartbeat":
            return

        print(message)
        # Here we can access lots of methods, for example to create an order:
        # if self.is_auth:  # only if the client is authenticated …
        #     await self.send_message(
        #         message={
        #             "method": "add_order",
        #             "params": {
        #                 "limit_price": 1234.56,
        #                 "order_type": "limit",
        #                 "order_userref": 123456789,
        #                 "order_qty": 1.0,
        #                 "side": "buy",
        #                 "symbol": "BTC/USD",
        #                 "validate": True,
        #             },
        #         }
        #     )
        # … it is also possible to call regular REST endpoints
        # but using the websocket messages is more efficient.
        # You can also un-/subscribe here using self.subscribe/self.unsubscribe.

async def main():
    try:
        # Public/unauthenticated websocket client
        client = Client()  # only use this one if you don't need private feeds
        await client.start()
        await client.subscribe(
            params={"channel": "ticker", "symbol": ["BTC/USD", "DOT/USD"]}
        )
        await client.subscribe(
            params={"channel": "book", "depth": 25, "symbol": ["BTC/USD"]}
        )
        # wait because unsubscribing is faster than unsubscribing … (just for that example)
        await asyncio.sleep(3)
        # print(client.active_public_subscriptions) # to list active subscriptions
        await client.unsubscribe(
            params={"channel": "ticker", "symbol": ["BTC/USD", "DOT/USD"]}
        )
        # …

        # AS default, the authenticated client starts two websocket connections,
        # one for authenticated and one for public messages. If there is no need
        # for a public connection, it can be disabled using the ``no_public``
        # parameter.
        client_auth = Client(key="api-key", secret="secret-key", no_public=True)
        await client_auth.start()
        await client_auth.subscribe(params={"channel": "balances"})

        while not client.exception_occur and not client_auth.exception_occur:
            await asyncio.sleep(6)
    finally:
        await client.close()
        await client_auth.close()

if __name__ == "__main__":
    asyncio.run(main())

📍 xStocks

Kraken recently added support for trading of tokenized stocks (xStocks) on their platform. The python-kraken-sdk fully supports this new feature, allowing users to trade xStocks seamlessly alongside other crypto assets.

For accessing xStocks, you can use the same SpotClient and SpotAsyncClient classes that are used for regular spot trading. The endpoints and methods for xStocks are integrated into these clients, making it easy to manage your xStock trades.

It is important to note that the xStocks feature is not available globally. Please check Kraken's documentation to understand the availability zones and ensure that you can trade xStocks from your location.

For trading or filtering for xStocks assets, the new asset class tokenized_asset must be used, e.g. when creating an order:

   from kraken.spot import SpotClient, Trade

   # Option 1: Create an order using the SpotClient directly:
   client = SpotClient(key="api-public-key", secret="api-secret-key")
   client.request(
       method="POST",
       uri="/0/private/AddOrder",
       params={
           "type": "buy",
           "volume": "1",
           "ordertype": "limit",
           "pair": "AAPLxUSD",
           "price": "100.0",
           "validate": True,
           "asset_class": "tokenized_asset", # 

# 📍 Futures Clients

The Kraken Spot API can be accessed by executing requests to the endpoints
directly using the `request` method provided by any client. This is demonstrated
below.

See https://docs.kraken.com/api/docs/guides/global-intro for information about
the available endpoints and their usage.

### `FuturesClient`

The simple Futures client provides access to all un-and authenticated endpoints.

```python
from kraken.futures import FuturesClient

client = FuturesClient(key="", secret="")
print(client.request("GET", "/derivatives/api/v3/accounts"))

FuturesAsyncClient

The async Futures client allows for asynchronous access to Kraken's Futures endpoints. Below are two examples demonstrating its usage.

Using FuturesAsyncClient without a context manager; In this example, the client is manually closed after the request is made.

import asyncio
from kraken.futures import FuturesAsyncClient

async def main():
    client = FuturesAsyncClient(key="", secret="")
    try:
        response = await client.request("GET", "/derivatives/api/v3/accounts")
        print(response)
    finally:
        await client.close()

if __name__ == "__main__":
    asyncio.run(main())

Using FuturesAsyncClient as context manager; This example demonstrates the use of the context manager, which ensures the client is automatically closed after the request is completed.

import asyncio
from kraken.futures import FuturesAsyncClient

async def main():
    async with FuturesAsyncClient(key="", secret="") as client:
        response = await client.request("GET", "/derivatives/api/v3/accounts")
        print(response)

if __name__ == "__main__":
    asyncio.run(main())

FuturesWSClient (Websocket API)

Not only REST, also the websocket API for Kraken Futures is available. Examples are shown below and demonstrated in examples/futures_ws_examples.py.

• https://docs.futures.kraken.com/#websocket-api

Note: Authenticated Futures websocket clients can also un-/subscribe from/to public feeds.

import asyncio
from kraken.futures import FuturesWSClient

class Client(FuturesWSClient):

    async def on_message(self, event):
        print(event)

async def main():
    try:
        # Public/unauthenticated websocket connection
        client = Client()
        await client.start()

        products = ["PI_XBTUSD", "PF_ETHUSD"]

        # subscribe to a public websocket feed
        await client.subscribe(feed="ticker", products=products)
        # await client.subscribe(feed="book", products=products)
        # …

        # unsubscribe from a public webs

…

## Source & license

This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [btschwertfeger](https://github.com/btschwertfeger)
- **Source:** [btschwertfeger/python-kraken-sdk](https://github.com/btschwertfeger/python-kraken-sdk)
- **License:** Apache-2.0
- **Homepage:** https://python-kraken-sdk.readthedocs.io/en/stable

Install and usage instructions live in the source repository linked above.