Production usage
Keep account state up to date
Use REST to submit orders and private WebSocket subscriptions to follow what happens next. Order, fill, balance and position events update your application's account state as changes occur.
- Connect the private streams and watch for subscription acknowledgements or errors before submitting orders. Load any starting state the streams do not provide, and account for events received while that data loads.
- Submit the order through REST. Save the returned IDs and inspect the response for errors or immediate results. An acknowledgement alone does not establish the order's later state.
- Apply matching WebSocket events to local state. Use order and fill events to track execution, and balance or position updates for the account changes your application needs. These events can arrive separately.
- Use REST to fill a specific gap: startup data, updates missed during a disconnect, conflicting events, or an outcome that neither the response nor the stream has resolved. Once account state is current, continue applying WebSocket updates.
Do not query REST after every submission or poll it while the required streams are healthy and complete. A quiet stream can mean nothing has changed. Check connection and subscription health separately from account activity.
Trigger follow-up work from position changes
Where the exchange and market provide position updates, they are useful triggers for follow-up logic. For example, when a position opens or increases, use its updated size to place or adjust stop-loss and take-profit (SL/TP) orders. Compare the previous and current position state; receiving another position message does not necessarily mean the position changed.
For signed position sizes, compare absolute exposure within the same direction and handle a direction change separately. Also resize or cancel obsolete protection when exposure shrinks or the position closes.
Debounce bursts of partial-fill updates to reduce API calls, and set a maximum wait so continuous updates cannot postpone adjustments indefinitely. Choose the debounce delay and maximum wait to fit the exchange's rate limits and the delay your strategy can tolerate.
When applying an adjustment:
- Check stream health and use the latest reconciled position and order state.
- Process changes for the same position sequentially and skip adjustments that are already satisfied.
- Pause dependent adjustments while recovering account state.
- Include the account, market and position side in state keys where applicable.
Recover after a connection gap
Use the SDK's reconnect lifecycle events to mark affected state as stale when connection recovery starts and to trigger REST reconciliation when the socket reopens. The event names differ by SDK; see the recovery section below. A reopened socket does not prove that authentication, subscriptions or account-state recovery are complete.
Confirm the required streams are healthy, load any missed order, fill, balance or position state, and account for updates received during those reads. Then compare current positions and open orders with the intended state and create, amend or cancel orders only where needed, including SL/TP orders. Resolve uncertain requests before submitting replacements so recovery does not create duplicates. Resume dependent actions once their required state is current.
See Account State for the full workflow. The private stream guide shows how to receive updates; the examples print events rather than maintain a complete account-state store.
Set timeouts and bound concurrency
Set an HTTP timeout for each operation and limit concurrent requests across workers. See Configuration for client options.
Retry reads deliberately
Retry transient read failures with a maximum attempt count or deadline, exponential backoff and jitter. Respect server retry guidance. Correct invalid parameters, permissions and signatures before retrying.
Resolve uncertain order outcomes
Kraken may accept an order even if the REST request times out. Check the private executions stream for the matching order or fill. If those events resolve the outcome, there is no need for a follow-up REST query.
If the response and stream leave the outcome unclear, use SpotClient.getOrders() with the exchange order ID. Without an ID, inspect open orders, closed orders and trades for the original pair, request time, side, price and volume. An empty or delayed result alone does not establish that the submission failed. Do not automatically repeat a state-changing request after a transport failure.
Save returned order IDs with the account and pair so you can match later events and recovery queries.
Recover streaming state
WebsocketClient reconnects and restores subscriptions automatically. reconnecting signals that connection recovery is starting; mark the affected account state as stale. reconnected means the socket has reopened and is a useful trigger for REST reconciliation of missed orders, executions and balances, plus positions when using Futures. Listen for exception to diagnose errors and let the SDK handle reconnection.
The SDK handles authentication and resubscription; these may still be completing when reconnected fires. No manual resubscription is needed. Process the resumed streams’ snapshots and updates, and account for events received during REST recovery. Compare current account state and open orders with the intended state before making follow-up changes; do not blindly recreate orders. Resume dependent actions once the state they need is current.
Market-data channels have their own snapshot, update and checksum rules. Track feed health; an open socket alone does not establish that the data is current.
Nonces and rate limits
Coordinate private requests that share an API key; independent processes can cause out-of-order nonces. Apply Kraken's REST and trading rate limits across the application, not separately in each worker.
Logging
Record operation names, response codes, duration, retries and reconnects. Select fields using the SDK's error format; whole request and error objects can contain credentials.
Shut down cleanly
Stop new work, settle or reconcile outstanding requests, call WebsocketClient.closeAll() and clear application timers. The stream example includes shutdown handlers.
Upgrading
Review release notes and run integration checks before upgrading. Commit the lockfile to reproduce deployed versions.