Read time … min

AI-native runtime for Kraken trading strategies

Author in Cursor, Claude Code or any AI IDE. Deploy from GitHub into a managed cloud runtime with first-class MCP control, logs and region selection.

By the TradingHost engineering team

Section 01 · At a glance

At a glance

Venue
Kraken
Venue type
Crypto exchange (spot, margin, futures, derivatives)
Asset class
Crypto, plus xStocks tokenised equities
Supported products
Spot, margin, perpetual and fixed-maturity futures via Kraken Futures (a separate venue at futures.kraken.com), tokenised stocks (xStocks). A CFTC-regulated US derivatives stack added via Payward’s May 2026 Bitnomial acquisition is expanding; perpetuals and options will follow per Kraken’s announcement.
Runtime model
Containerised strategy runtime
Deployment source
GitHub
Languages
Any language that runs in a container
Common integrations
Native Kraken REST, WebSocket and FIX, CCXT (kraken, krakenfutures), Freqtrade, Hummingbot, custom connectors
AI workflow integration
MCP control surface for Cursor, Claude Code, GitHub Copilot and CLI agents
TradingHost role
Runtime, deployment, logs, health checks, region selection, MCP control
Kraken role
Exchange account, API access, market access, execution venue
Affiliation
TradingHost is independent and is not affiliated with Kraken or Payward, its parent. Payward completed its acquisition of Bitnomial on May 4, 2026.

Section 02 · What Kraken offers

What Kraken offers

Kraken Spot and margin live at api.kraken.com, with HMAC-SHA512-signed REST and both v1 and v2 WebSocket feeds. Kraken Futures lives at futures.kraken.com as a separate venue with its own API key set and signing scheme, covering perpetuals and dated contracts. Both surfaces speak FIX 4.4 for institutional clients. The Bitnomial-backed CFTC-regulated US derivatives stack added by Payward in May 2026 is expanding into perpetuals and options. Endpoint specifics change over time; the shape is durable, the precise rate-limit weights, fee tiers and symbol lists live in Kraken's docs.

Markets and strategy patterns

  • Spot market making across Kraken Pro pairs
  • Margin trading with up to 5x on supported pairs
  • Perpetual futures on Kraken Futures (multi-collateral, USD-settled)
  • Fixed-maturity futures (monthly and quarterly) on Kraken Futures
  • Cross-venue arbitrage between Kraken spot and Kraken Futures
  • xStocks tokenised equity strategies via Kraken spot
  • FIX 4.4 institutional execution from a colocated runtime
  • CFTC-regulated US derivatives flow via the Bitnomial-backed Payward stack

API surface

Product surfaces
Spot and margin via api.kraken.com, Futures (perpetuals and dated) via futures.kraken.com. Demo environment for Futures only at demo-futures.kraken.com. No public testnet for Spot, so dry-runs hit the live API with minimum-size orders or recorded data.
Connection methods
REST, WebSocket v1, WebSocket v2 (out of beta since December 2023, both maintained), FIX 4.4 for Spot and Futures (institutional only, requires a SPOT API Key with FIX type).
Authentication
Spot REST uses HMAC-SHA512 over (URI path + SHA256(nonce + POST data)) with API-Key and API-Sign headers and a monotonically increasing nonce. Futures REST uses a separate API key set generated at futures.kraken.com with APIKey + Authent headers and a different signing scheme. Optional 2FA on API keys (TOTP or static password). Spot and Futures auth surfaces are completely separate.

For specifics, refer to Kraken

Specific endpoints, rate-limit weights, symbol lists, fee tiers and version history live in Kraken's documentation. Treat these as the source of truth.

Section 03 · Build with AI

Build your Kraken strategy with AI

Pick an integration method, fork a TradingHost framework starter, and author your strategy in an AI IDE. Cursor, Claude Code, GitHub Copilot and CLI-based AI agents all work with the same GitHub-native deployment loop.

  • Native Kraken API

    Direct control over Kraken-specific behaviour, account data and order execution logic.

  • CCXT

    Common interface across Kraken Spot, Kraken Futures and other crypto exchanges. CCXT exposes Kraken as two separate exchange ids: `kraken` for Spot and margin, `krakenfutures` for perps and dated futures.

    Get started with CCXT

  • Freqtrade or Hummingbot

    Framework-based deployments using their strategy structure and configuration model. Both frameworks ship first-class Kraken Spot support.

    Get started with FreqtradeGet started with Hummingbot

  • Custom connector

    Your own internal trading engine or proprietary Kraken integration.

Framework support for Kraken products

Coverage varies by framework. CCXT covers Kraken Spot and Kraken Futures from one library through two separate exchange ids (`kraken` and `krakenfutures`). Freqtrade and Hummingbot ship first-class Kraken Spot support. Native Kraken API access covers the full surface, including margin on api.kraken.com and the separate Futures venue at futures.kraken.com.

FrameworkSpotMarginFutures
Native Kraken APISupportedSupportedSupported
CCXTSupportedSupportedSupported
FreqtradeSupportedNot documented as supportedNot documented as supported
HummingbotSupportedNot documented as supportedNot documented as supported

✓ confirmed support per official framework docs. "no" indicates not officially documented as supported.

TradingHost does not force a framework. It runs your project.

Author with AI

The framework starters above pair naturally with AI IDEs. The TradingHost MCP control surface closes the loop: AI tools can inspect deployments, review logs and manage the runtime alongside you, never the trade execution path.

Section 04 · Run on TradingHost

Run your code on TradingHost

Kraken provides the exchange and API access. TradingHost provides the production environment where your Kraken-connected strategy runs.

Instead of running strategy code on a laptop, desktop machine, generic VPS or manually configured server, you deploy from GitHub into a TradingHost-managed container runtime.

You

  • Your repo contains your code.
  • Your deployment defines how it runs.
  • Your strategy connects to Kraken.

TradingHost

  • Keeps the runtime online.
  • Surfaces logs and health checks.
  • Region selection.
  • Controlled deployment surface.

Deployment flow

  1. STEP 01

    Connect GitHub

    Authorise TradingHost to access your GitHub account.

  2. STEP 02

    Link a repo or start from a framework

    Point TradingHost at your existing strategy repo, or fork a TradingHost framework runtime (CCXT, Freqtrade or Hummingbot) for a working baseline.

  3. STEP 03

    Deploy into a TradingHost container

    Pick a region (EU or US-East), supply the environment values your strategy needs (Kraken API keys for Spot and/or Futures, etc.), and deploy. TradingHost builds your container from the repo and runs your strategy on managed Kubernetes infrastructure. No local Docker install required.

  4. STEP 04

    Monitor logs and health

    Watch live logs, health and runtime state from the TradingHost dashboard. The same surface is reachable through MCP from any AI IDE, so Cursor, Claude Code or a CLI agent can read deployment state and manage the runtime alongside you.

  5. STEP 05

    Update and redeploy

    Push changes to your GitHub main branch and TradingHost redeploys automatically.

Deploy

Section 05 · Operational notes

Operational notes for Kraken

Things that bite you when you actually run a Kraken strategy in a containerised cloud runtime, not in Kraken's docs, not in framework READMEs. Every claim below is quoted or paraphrased from Kraken's own documentation; the deployment-side guidance is from running these strategies on TradingHost.

  1. 01 · Nonce

    Kraken's nonce check is strict and shared per key

    Every Spot REST private request must carry a strictly increasing nonce per API key. Parallel requests or any clock-skew between processes produce EAPI:Invalid nonce. The standard fix is one key per worker plus nanosecond-resolution nonces; Kraken also exposes a configurable Nonce Window on each key to absorb out-of-order arrivals.

    SourceKraken support: Invalid nonce errors

  2. 02 · WebSockets

    v1 and v2 both live, v2 is recommended

    WebSocket v2 left beta in December 2023 and is the API Kraken steers new integrations toward, with a FIX-style schema, RFC3339 timestamps and numeric prices. v1 still receives patches and has no announced sunset, but new code should target v2 unless you depend on a v1-only feed.

    SourceKraken API change logKraken WebSocket v2 overview

  3. 03 · Separate stacks

    Spot and Futures are two different APIs with two key sets

    Spot lives at api.kraken.com with HMAC-SHA512 signing. Futures lives at futures.kraken.com with the APIKey + Authent header pair and a different signing algorithm. Keys are minted from different account areas and are not interchangeable. A unified strategy that touches both holds two credentials and two clients.

    SourceKraken Futures REST introduction

  4. 04 · Rate limits

    Per-tier counter that decays continuously

    Kraken uses a counter model where each call costs a fixed amount and the counter decays per second according to verification tier: Starter caps at 60 with -1/s decay, Intermediate at 125 with -2.34/s, Pro at 180 with -3.75/s. The same counter is shared across REST, WebSocket and FIX, so you cannot escape it by switching transports. Hitting it returns EOrder:Rate limit exceeded.

    SourceKraken Spot REST rate limits

  5. 05 · Testnet

    Futures has a real demo environment, Spot does not

    Kraken provides a full demo at demo-futures.kraken.com that mirrors the live Futures REST and WebSocket surface, with separate sign-up and separate keys. There is no equivalent sandbox for Spot. Strategy validation against Spot has to be done against the live API with minimum-size orders or against recorded data.

    SourceKraken support: Futures demo environment

  6. 06 · Order types

    Post-only, iceberg, trailing stop, plus full TIF set

    Kraken's order schema supports post-only, iceberg (displays a slice down to 1/15 of order_qty), and trailing stops on both Spot and Futures. Time-in-force covers GTC, IOC, GTD and post-only. These map cleanly through CCXT params but Freqtrade only exposes GTC, IOC and PO.

    SourceKraken WebSocket v2 add_order schema

  7. 07 · Errors

    Read the prefix: EAPI vs EOrder vs EGeneral

    EAPI:Invalid key usually means signature construction is wrong (wrong path, wrong HMAC, wrong base64) rather than a revoked key. EAPI:Invalid nonce is ordering, not credentials. EOrder:Insufficient funds reflects available balance after open orders and positions, not raw wallet balance. EGeneral:Permission denied indicates missing key scopes.

    SourceKraken support: API error messagesKraken Spot errors reference

Section 06 · Built for

Built for

TradingHost Kraken runtimes are best suited to:

  • Developers building strategies in AI IDEs (Cursor, Claude Code)
  • Systematic crypto traders
  • Quant developers
  • CCXT, Freqtrade and Hummingbot users
  • Teams moving from VPS hosting to containerised deployment

Connecting GitHub and creating your first strategy is free.

Section 08 · FAQ

FAQ

No. TradingHost is independent and is not affiliated with Kraken or Payward, its parent.

No. Your strategy code connects to Kraken and sends instructions according to your own logic, account permissions and integration method. TradingHost provides the runtime where that code runs.

No. Kraken API access is provided by Kraken. You are responsible for your Kraken account, API permissions, credentials and compliance with Kraken’s terms.

No. TradingHost is the cloud runtime where your strategy code runs. We do not provide signals, AI prediction models or pre-built bots. With TradingHost you write or generate the strategy yourself (often with Cursor or Claude Code), keep it in GitHub as your code, and use TradingHost to run it in production. 3Commas, Cryptohopper and similar products own the strategy logic; TradingHost runs your strategy.

AWS and DigitalOcean give you raw compute. You handle OS updates, container orchestration, log shipping, secret rotation, region failover and uptime monitoring yourself. TradingHost gives you a managed runtime purpose-built for trading strategies: GitHub-native deployment, MCP-driven control from AI IDEs, log and health surfaces out of the box. If you want to operate the infrastructure yourself, AWS works. If you want the runtime as a managed service, TradingHost is the shorter path.

Yes. TradingHost runs Python strategies; pick the framework runtime that matches your stack or deploy your own repo.

Yes. TradingHost supports any language that can run inside a container.

Yes. CCXT ships two separate exchanges: kraken for Spot and margin, and krakenfutures for perps and dated futures. They take two different API key sets. TradingHost runs your CCXT container against either or both. Mount the right credentials as secrets. See the CCXT framework runtime for the full setup story.

Yes. Spot keys are created in your main Kraken account at kraken.com; Futures keys are created separately under futures.kraken.com. The two authentication schemes differ (HMAC-SHA512 with API-Sign for Spot, APIKey + Authent header for Futures), so a strategy that trades both needs two credentials and typically two clients.

For pure Spot, Freqtrade has first-class Kraken support. For cross-venue or perpetual futures work, CCXT covers both kraken and krakenfutures from one library. Hummingbot's kraken connector is the cleanest market-making option but is Spot-only.

Yes, if your project is designed that way. You can run multiple strategy processes or services inside one runtime, or separate them into different runtimes for isolation and operational clarity. See the TradingHost runtime page for the multi-strategy model.

The fastest path is to fork a TradingHost framework runtime: CCXT, Freqtrade or Hummingbot for a ready-to-deploy project. Or connect your own GitHub strategy repo. Linking a GitHub repo and creating a strategy is free; runtime plans are listed on the pricing page.

In your GitHub-controlled secrets workflow. TradingHost reads them at runtime through GitHub repository secrets, environment secrets or your own approved secret-management process. TradingHost does not need custody of your API key and secret. See platform secrets for the full handling model.

No. Strategies should never need withdrawal permissions. Use scoped permissions (query funds, query open orders, create/modify orders, websocket access) and IP whitelisting where appropriate.

Yes. TradingHost supports MCP-based control for AI IDEs including Cursor, Claude Code, GitHub Copilot and CLI-based AI agents. AI tools can inspect deployments, review logs, restart strategies and manage runtime workflows. MCP is a control and observability surface, not the trade execution path. See the MCP control surface for the full picture.

Both. The MCP control surface works equally well from CLI-based agents (Claude Code CLI, custom MCP clients, scripted MCP calls) and from inside an IDE. The GitHub-native deployment loop also works without any AI tooling: a regular git push to your main branch triggers a redeploy.

The runtime detects the crash and exposes the relevant logs and health information. Where supported, the affected strategy can be restarted without disrupting other strategies running in the same container. Your strategy code is still responsible for safe error handling, duplicate-order protection and risk controls. See observability for the logs and health surface.

Kraken requires monotonically increasing nonces per API key, and any parallelism breaks that. Run one key per worker process, use a nanosecond-resolution nonce, and widen the key's Nonce Window in Kraken settings if you still see collisions under burst load. TradingHost surfaces these errors directly in container logs. See the Operational notes section above for the full guidance.

For Futures, yes: demo-futures.kraken.com is a full mirror of the live Futures API with separate sign-up and separate keys. For Spot there is no public sandbox, so dry-runs happen against the live API with minimum-size orders or against recorded data inside the runtime.

TradingHost runs in the EU and US-East regions. Pick the region closest to the matching engine your strategy depends on. See the regions page for routing and proximity details.

No. TradingHost is focused on production runtime and deployment. Backtesting belongs in your research stack, framework or AlgoBuilder.