Kraken Spot and Futures API Integration in Delphi

Kraken is one of the longest-running and most trusted cryptocurrency exchanges, offering both spot and futures markets. The TsgcWSAPI_Kraken and TsgcWSAPI_Kraken_Futures components for Delphi provide full access to Kraken's WebSocket and REST APIs, enabling real-time market data streaming, account management, order placement, and futures trading from a single codebase.

Overview

Kraken's API is split into two distinct platforms, each with its own component:

Both components provide a dual-channel approach: WebSocket connections for low-latency real-time data streaming, and REST endpoints for request/response operations such as querying balances, placing orders, and retrieving historical data.

Configuration

Both the Spot and Futures components require API credentials for private (authenticated) operations. Public endpoints like market data do not require authentication.

Spot WebSocket API

The Spot WebSocket API provides real-time streaming for market data and private account events. Methods are divided into public channels (no authentication required) and private channels (require a valid WebSocket token).

Public Channels

Private Channels

// Subscribe to public ticker data for BTC/USD
oKraken.SubscribeTicker('XBT/USD');

// Subscribe to the order book with 10-level depth
oKraken.SubscribeBook('XBT/USD');

// Subscribe to real-time trades
oKraken.SubscribeTrade('ETH/USD');

// Subscribe to private channels (requires API key)
oKraken.SubscribeOwnTrades;
oKraken.SubscribeOpenOrders;

Spot REST API

The Spot REST API is accessed through the REST_API property of the TsgcWSAPI_Kraken component. It provides a comprehensive set of endpoints for market data queries, account management, trading, and fund operations.

Public REST Methods

Private REST Methods - Account and Trading

Private REST Methods - Export and Reporting

Private REST Methods - Funding

// Public REST: Get ticker data
ShowMessage(oKraken.REST_API.GetTicker('XBTUSD'));

// Public REST: Get OHLC data
ShowMessage(oKraken.REST_API.GetOHLC('XBTUSD'));

// Private REST: Get account balance
ShowMessage(oKraken.REST_API.GetAccountBalance);

// Private REST: Get open orders
ShowMessage(oKraken.REST_API.GetOpenOrders);

Futures WebSocket API

The TsgcWSAPI_Kraken_Futures component provides real-time streaming for Kraken's futures markets, including perpetual contracts and fixed-maturity futures.

Public Channels

Private Channels

Futures REST API

The Futures REST API is accessed through the REST_API property of TsgcWSAPI_Kraken_Futures. It provides endpoints for market data, order management, account queries, and fund transfers.

Public REST Methods

Private REST Methods - Account and Orders

Private REST Methods - Order Management

Private REST Methods - Transfers and Reporting

Complete Code Example

The following example demonstrates connecting to the Kraken Spot API, fetching market data via REST, querying your account balance, and subscribing to a real-time ticker feed via WebSocket.

var
  oClient: TsgcWebSocketClient;
  oKraken: TsgcWSAPI_Kraken;
begin
  // Create and configure the WebSocket client
  oClient := TsgcWebSocketClient.Create(nil);
  oKraken := TsgcWSAPI_Kraken.Create(nil);
  oKraken.Client := oClient;

  // Configure API credentials for private endpoints
  oKraken.Kraken.ApiKey := 'your_api_key';
  oKraken.Kraken.ApiSecret := 'your_api_secret';

  // Connect to Kraken
  oClient.Active := True;

  // REST: Get ticker data for BTC/USD
  ShowMessage(oKraken.REST_API.GetTicker('XBTUSD'));

  // REST: Get account balance (requires API key)
  ShowMessage(oKraken.REST_API.GetAccountBalance);

  // WebSocket: Subscribe to real-time ticker
  oKraken.SubscribeTicker('XBT/USD');
end;

Futures Example

Setting up the Futures component follows the same pattern, using TsgcWSAPI_Kraken_Futures instead:

var
  oClient: TsgcWebSocketClient;
  oFutures: TsgcWSAPI_Kraken_Futures;
begin
  oClient := TsgcWebSocketClient.Create(nil);
  oFutures := TsgcWSAPI_Kraken_Futures.Create(nil);
  oFutures.Client := oClient;

  // Configure API credentials
  oFutures.Kraken.ApiKey := 'your_futures_api_key';
  oFutures.Kraken.ApiSecret := 'your_futures_api_secret';

  oClient.Active := True;

  // REST: Get all available futures instruments
  ShowMessage(oFutures.REST_API.GetInstruments);

  // REST: Get account information
  ShowMessage(oFutures.REST_API.GetAccounts);

  // WebSocket: Subscribe to futures ticker
  oFutures.SubscribeTicker('PI_XBTUSD');

  // WebSocket: Subscribe to private account updates
  oFutures.SubscribeOpenPositions;
  oFutures.SubscribeAccountBalanceAndMargins;
end;

Notes and Best Practices

Spot vs. Futures API Keys

Kraken uses separate API keys for spot and futures trading. Generate dedicated keys for each platform from the Kraken settings page. Do not reuse the same key across both components.

WebSocket Token for Private Channels

Private WebSocket subscriptions on the spot exchange require a temporary token obtained via the GetWebSocketsToken REST method. The component handles this automatically when API credentials are configured, but be aware that tokens expire and will be refreshed as needed.

Rate Limits

Kraken enforces rate limits on both REST and WebSocket APIs. REST endpoints use a counter-based system where each call increments a counter, and the counter decays over time. Exceeding the limit results in temporary lockout. Use WebSocket subscriptions for real-time data instead of polling REST endpoints.

Asset Pair Naming