Kraken CLI

The first AI-native CLI for trading crypto, stocks, forex, and derivatives.

Full Kraken API access. Built-in MCP server. Live and paper trading. Single binary.

Works with Cursor, Claude, Codex, Copilot, Gemini, Goose, and OpenClaw.

Try these with your AI agent:

"Install kraken-cli (https://github.com/krakenfx/kraken-cli) and build me a morning market brief."

"Watch ETH, SOL, and BTC for 30 seconds. What are the pros and cons of buying each right now?"

"Look up AAPLx, TSLAx, and SPYx on xStocks. Summarize how each is performing today."

"You are a Wall Street veteran with 20 years of experience. You have 1 minute. Paper trade BTC and show me your P&L."

[!CAUTION] Experimental software. Interacts with the live Kraken exchange and can execute real financial transactions. Read DISCLAIMER.md before using with real funds or AI agents.

Contents

• Installation
• What You Can Trade
• Quick Start
• MCP Server
• Paper Trading
• Commands
• API Keys & Configuration
• Verifying Binaries
• Contributing
• License & Disclaimer

Installation

Single binary, no runtime dependencies.

One-liner

curl --proto '=https' --tlsv1.2 -LsSf https://github.com/krakenfx/kraken-cli/releases/latest/download/kraken-cli-installer.sh | sh

Detects your OS and architecture, downloads the right binary, and installs it. macOS (Apple Silicon and Intel) and Linux (x86_64 and ARM64) are supported. Windows: use WSL.

Verify it works:

kraken status && kraken ticker BTCUSD

Pre-built binaries are also available on the GitHub Releases page.

cargo install --git https://github.com/krakenfx/kraken-cli

git clone https://github.com/krakenfx/kraken-cli.git
cd kraken-cli
cargo install --path .

What You Can Trade

One binary covers six asset classes. All trading commands work across asset classes using the same interface; pass --asset-class where needed.

xStocks are not available in the USA. Availability for all products varies by jurisdiction.

For AI Agents

If you're an AI agent or building one, start here:

Core invocation pattern:

kraken <command> [args...] -o json 2>/dev/null

• stdout is always valid JSON on success, or a JSON error envelope on failure.
• Exit code 0 means success. Non-zero means failure.
• stderr carries diagnostics only (enabled with -v). Never parse stderr for data.

Verifying Binaries

Release binaries are signed with minisign. Every artifact on the Releases page has a corresponding .minisig signature file.

Public key:

RWQJue8SwPzZBZO8Up5ppAUqm0wM/gK5yjnam+Dbf7KbY0utkiO+7XCd

Verify a downloaded binary:

minisign -Vm kraken-cli-aarch64-apple-darwin.tar.gz -P RWQJue8SwPzZBZO8Up5ppAUqm0wM/gK5yjnam+Dbf7KbY0utkiO+7XCd

Install minisign: brew install minisign (macOS) or apt install minisign (Linux).

Quick Start

Public market data requires no credentials:

kraken ticker BTCUSD -o json
kraken orderbook BTCUSD --count 10 -o json
kraken trades BTCUSD --count 20 -o json
kraken ohlc BTCUSD --interval 60 -o json

With authentication:

export KRAKEN_API_KEY="your-key"
export KRAKEN_API_SECRET="your-secret"
kraken balance -o json
kraken open-orders -o json
kraken order buy BTCUSD 0.001 --type limit --price 50000 -o json

For humans (table output, interactive setup):

kraken setup
kraken ticker BTCUSD
kraken balance
kraken shell

API Keys & Configuration

Authenticated commands (trading, balances, order management) require a Kraken API key pair. Public market data and paper trading work without credentials.

Getting API keys

Spot (covers trading, balances, funding, earn, subaccounts): Settings > API on kraken.com. Full guide: How to create a spot API key.

Futures (only for kraken futures commands): Settings > Create Key on the Futures interface. Full guide: How to create a Futures API key.

Grant the minimum permissions your workflow needs. For read-only monitoring, "Query Funds" and "Query Open Orders & Trades" are sufficient.

Environment variables (recommended for agents)

export KRAKEN_API_KEY="your-key"
export KRAKEN_API_SECRET="your-secret"
export KRAKEN_FUTURES_API_KEY="your-futures-key"       # optional
export KRAKEN_FUTURES_API_SECRET="your-futures-secret"  # optional

Config file (for humans)

Store credentials in ~/.config/kraken/config.toml:

[auth]
api_key = "your-api-key"
api_secret = "your-api-secret"
[settings]
default_pair = "BTCUSD"
output = "table"

Or use the interactive wizard: kraken setup.

Credential resolution

Highest precedence first:

1. Command-line flags (--api-key, --api-secret)
2. Environment variables (KRAKEN_API_KEY, KRAKEN_API_SECRET)
3. Config file (~/.config/kraken/config.toml)

Security

• Config file is created with 0600 permissions (owner read/write only)
• Secrets are never logged, printed, or included in error messages
• Use --api-secret-stdin or --api-secret-file instead of --api-secret to avoid secrets in process listings
• For automation, prefer environment variables over command-line flags

MCP Server

kraken-cli includes a built-in Model Context Protocol server over stdio. No subprocess wrappers needed.

MCP tool calls run through the same command path as CLI commands and inherit the same error handling and rate-limit behavior.

[!WARNING] MCP is local-first and designed for your own machine. Any agent connected to this MCP server uses the same configured Kraken account and API key permissions. Do not expose, tunnel, or share this server outside systems you control. Always use https:// and wss:// endpoints. Treat this integration as alpha and use least-privilege API keys.

kraken mcp                           # read-only (market, account, paper)
kraken mcp -s all                    # all services, dangerous calls require acknowledged=true
kraken mcp -s all --allow-dangerous  # all services, no per-call confirmation
kraken mcp -s market,trade,paper     # specific services

Configure your MCP client (Claude Desktop, ChatGPT, Codex, Gemini CLI, Cursor, VS Code, Windsurf, etc.):

{
  "mcpServers": {
    "kraken": {
      "command": "kraken",
      "args": ["mcp", "-s", "all"]
    }
  }
}

Gemini CLI users can install directly: gemini extensions install https://github.com/krakenfx/kraken-cli

Service groups

Default: market,account,paper. Streaming groups (websocket, futures-ws) are excluded in MCP v1.

Dangerous tools carry the destructive_hint annotation and include [DANGEROUS: requires human confirmation] in the description. In guarded mode (default), dangerous calls must include acknowledged=true. In autonomous mode (--allow-dangerous), this requirement is disabled.

kraken ticker BTCUSD -o json
# {"BTCUSD":{"a":["67234.10","1","1.000"],"b":["67234.00","1","1.000"],...}}

┌──────────┬──────────┬──────────┬──────────┬────────────┐
│ Pair     │ Ask      │ Bid      │ Last     │ Volume ... │
├──────────┼──────────┼──────────┼──────────┼────────────┤
│ BTCUSD   │ 67234.10 │ 67234.00 │ 67234.10 │ 1234.56    │
└──────────┴──────────┴──────────┴──────────┴────────────┘

{"error": "auth", "message": "Authentication failed: EAPI:Invalid key"}

kraken balance -o json -v 2>/dev/null | jq .

Commands

134 commands across 12 groups. For machine-readable parameter schemas, load agents/tool-catalog.json.

32 commands are marked dangerous (orders, withdrawals, transfers, cancel-all, staking). The authoritative list is the dangerous field in agents/tool-catalog.json.

Paper Trading

Paper trading provides a safe sandbox for testing trading logic against live Kraken prices. No API keys, no account, no real money. The command interface mirrors live trading exactly; agents can switch between paper and live by changing the command prefix (kraken paper buy vs kraken order buy).

Agent pattern:

kraken paper init --balance 10000 -o json
kraken paper buy BTCUSD 0.01 -o json
kraken paper sell BTCUSD 0.005 --type limit --price 70000 -o json
kraken paper status -o json
kraken paper reset -o json

Human pattern:

kraken paper init --balance 5000 --currency EUR
kraken paper buy BTCUSD 0.01
kraken paper balance
kraken paper status
kraken paper orders
kraken paper history
kraken paper reset

Prices come from the public Kraken Ticker API (no auth needed). A 0.26% taker fee (Kraken Starter tier default) is applied to all fills. Limit orders fill at the limit price when the live market crosses the order price.

All output is labeled [PAPER] in table mode and includes "mode": "paper" in JSON mode.

Examples

Conditional order based on live price

PRICE=$(kraken ticker BTCUSD -o json | jq -r '.[].c[0]')
kraken order buy BTCUSD 0.001 --type limit --price "$PRICE" -o json

Portfolio rebalance check

BTC=$(kraken balance -o json | jq -r '.BTC // "0"')
if [ "$(echo "$BTC > 0.001" | bc)" -eq 1 ]; then
kraken order sell BTCUSD 0.001 --type market -o json
fi

Real-time price stream

kraken ws ticker BTC/USD -o json | while read -r line; do
  LAST=$(echo "$line" | jq -r '.data[0].last // empty')
  [ -n "$LAST" ] && echo "BTC: $LAST"
done

Stream multiple tickers

kraken ws ticker BTC/USD ETH/USD SOL/USD -o json

Dead man's switch

kraken order cancel-after 60

Cancels all open orders if the CLI does not reset the timer within 60 seconds.

Agent Skills

Ships with 50 agent skills covering trading strategies, market analysis, and portfolio management. See the full Skills Index.

xattr -d com.apple.quarantine /usr/local/bin/kraken

src/
  main.rs          -- CLI entry point, clap parsing, exit codes
  lib.rs           -- AppContext, shared dispatcher, module re-exports
  auth.rs          -- HMAC-SHA512 signing (Spot + Futures), nonce management
  config.rs        -- Config file I/O, credential resolution, secret wrappers
  client.rs        -- HTTP clients with transient-error retry and enriched rate-limit errors
  errors.rs        -- Unified error types with category-based JSON envelopes
  paper.rs         -- Paper trading state engine (local simulation)
  shell.rs         -- Interactive REPL with rustyline
  telemetry.rs     -- Agent client identification, instance tracking, user-agent
  commands/        -- One module per command group
    mod.rs         -- Module re-exports
    helpers.rs     -- Shared utilities (JSON extraction, output formatting)
    market.rs      -- Public market data
    account.rs     -- Private account data
    trade.rs       -- Spot trading
    funding.rs     -- Deposits, withdrawals, wallet transfers
    earn.rs        -- Staking/earn
    subaccount.rs  -- Subaccount management
    futures.rs     -- Futures trading and market data
    futures_ws.rs  -- Futures WebSocket v1 streaming
    websocket.rs   -- Spot WebSocket v2 streaming
    paper.rs       -- Paper trading commands
    auth.rs        -- Credential management commands
    utility.rs     -- Setup wizard
  mcp/             -- Built-in MCP server
    mod.rs         -- Service group parsing, streaming exclusion filters
    server.rs      -- ServerHandler impl, tool dispatch, env-based URL resolution
    registry.rs    -- Tool registry built from clap tree + tool-catalog.json
    schema.rs      -- JSON Schema generation from clap argument metadata
  output/          -- Rendering layer
    mod.rs         -- Format dispatch, CommandOutput type
    table.rs       -- Human-readable table output
    json.rs        -- JSON output and NDJSON streaming

Development

cargo build                    # dev build
cargo test                     # run tests
cargo clippy -- -D warnings    # lint

Contributing

Bug reports, feature requests, and pull requests are welcome. See CONTRIBUTING.md for guidelines.

License & Disclaimer

MIT. See LICENSE.

This is experimental software. Commands interact with the live Kraken exchange and can result in real financial transactions. Orders, withdrawals, and transfers are irreversible once processed. The authors accept no liability for financial losses. See DISCLAIMER.md for full terms.