Kraken MCP for AI. Analyze crypto positions and balances instantly.
Works with every AI agent you already use
…and any MCP-compatible client








How this MCP server connects to your AI agent
Kraken MCP gives your agent direct access to real-time crypto market data; you can pull current asset balances, check trade history, and analyze order book depth from both spot and futures markets.
It's a full portfolio management suite built right into any AI client.
What AI agents can do with Kraken Automation
Futures get history
Retrieves a list of completed trade transactions for futures contracts.
Futures get orderbook
Gets the current buy and sell depth (the order book) for specific futures pairs.
Futures get tickers
Fetches real-time ticker information for various futures contracts.
Check your total spot and trade balances, or list open and closed orders across your entire Kraken account.
Get real-time ticker information, the full order book for futures contracts, and historical OHLC data for backtesting models.
Send new orders or cancel existing positions (both spot and futures) directly through your agent's workflow.
Query the full list of available asset pairs, helping you identify markets that haven't been analyzed yet.
Ask an AI about this
Waiting for input…
What AI agents can do with Kraken Alternative with 28 Tools
This collection of tools lets you query every aspect of the Kraken exchange, from simple balance checks to complex futures trading functions.
Make your AI actually useful.
Add this MCP to Claude, Cursor, or Windsurf and your AI stops guessing. It gets real tools to look things up, take action, and handle the stuff you keep doing by hand.
Start using Kraken on VinkiusFutures Get History
Retrieves a list of completed trade transactions for futures contracts.
Futures Get Orderbook
Gets the current buy and sell depth (the order book) for specific futures pairs.
Futures Get Tickers
Fetches real-time ticker information for various futures contracts.
Futures Send Order
Allows you to submit a new trade order specifically for the futures market.
Spot Add Order
Places a new trading limit or market order in the main spot market.
Spot Cancel All Orders After
Cancels all orders placed after a specific date or time stamp, useful for cleanup.
Spot Cancel All
Cancels every single open order on your account at once.
Spot Cancel Order
Removes a single, specified order from your account.
Spot Get Asset Pairs
Lists all the distinct crypto pairs that are currently tradable on Kraken.
Spot Get Assets
Provides general information about specific cryptocurrencies listed on the exchange.
Spot Get Balance
Retrieves your current cash and crypto balances across your spot account.
Spot Get Closed Orders
Fetches details on orders that have already been filled or canceled.
Spot Get Depth
Displays the current buy/sell order book depth for spot trading pairs.
Spot Get Ledgers
Retrieves detailed records of all ledger movements and transactions on your account.
Spot Get Ohlc
Pulls historical Open, High, Low, Close data for charting purposes.
Spot Get Open Orders
Shows all the active limit or market orders currently sitting in your open order...
Spot Get Open Positions
Lists assets that you currently hold a net position on.
Spot Get Spread
Provides the recent price difference (the spread) between buy and sell prices for pairs.
Spot Get System Status
Checks Kraken’s overall system uptime and health status to ensure optimal trading conditions.
Spot Get Ticker
Gets the latest, most basic price information for any supported crypto pair.
Spot Get Time
Returns the current synchronized server time from Kraken.
Spot Get Trade Balance
Retrieves your available balance specifically for executing trades.
Spot Get Trade Volume
Calculates the total trading volume over a specified period.
Spot Get Trades History
Retrieves a comprehensive historical log of all your crypto trades.
Spot Get Trades
Fetches a list of recent, executed trades in the spot market.
Spot Get Websockets Token
Generates a temporary token needed to connect streaming web socket data.
Spot Query Orders
Searches and reports on your order history, including both active and closed orders.
Spot Query Trades
Queries a detailed log of trade activity based on specific criteria.
Security and governance baked right in.
Pick your AI client below to get set up. Just create a Vinkius account, subscribe, and you're instantly up and running. We handle the entire backend infrastructure, delivering out-of-the-box support for HTTPS Streamable, SSE, and OAuth2—zero messy routing required.
Choose How to Get Started
Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.
Build Your Own
Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.
- Import from OpenAPI, Swagger, or YAML specs
- Create Agent Skills with progressive disclosure
- Deploy to edge with MCPFusion framework
- Built in DLP, auth, and compliance on every call
- Real time usage dashboard and cost metering
- Publish to catalog or keep private
Make Your AI Do More
Start with Kraken, then connect any of our 5,100+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 5,100+ others, all in one place
- Add new capabilities to your AI anytime you want
- Every connection is secured and compliant automatically
- Track usage and costs across all your servers
- Works with Claude, ChatGPT, Cursor, and more
- New servers added to the catalog every week
Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Kraken. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.
VINKIUS INFRASTRUCTURE
Cloud Hosted
Managed infra
V8 Isolated
Sandboxed per request
Zero-Trust Proxy
No stored credentials
DLP Enforced
Policy on every call
GDPR Compliant
EU data residency
Token Compression
~60% cost reduction
Built on the Model Context Protocol (MCP) for Claude, ChatGPT, Cursor, and more
The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.
This connection provides 28 powerful capabilities that interface natively with Claude, ChatGPT, Cursor, and other compatible AI platforms. No middleware. No custom integration required.
The headache of checking balances and trade history today, Solved with Vinkius AI Gateway
Right now, monitoring your crypto positions means logging into Kraken, switching between the 'Dashboard' tab, the 'Trades' log, and sometimes a separate 'History' page. You copy the balance from one place, then click through several tabs just to find out if an order was partially filled; it’s tedious, and you inevitably miss something.
With this MCP, that whole multi-step process vanishes. You simply tell your agent: 'What are my current balances and how many trades closed yesterday?' It runs the necessary functions, like `spot_get_balance` and `spot_get_closed_orders`, and gives you a single, unified answer—no clicking required.
Getting real-time data with Kraken MCP
You don't have to manually fetch asset pairs using `spot_get_asset_pairs` just to figure out what you can trade; the agent knows that information is available and helps structure your queries based on those available assets. It also automatically checks system health via `spot_get_system_status`, so you aren't wasting time querying a dead endpoint.
The difference now is control. You dictate the data needs, whether it’s getting a full list of open positions (`spot_get_open_positions`) or retrieving deep ledger details using `spot_get_ledgers`. It moves complex API calls into plain conversation.
What your AI can actually do with this
Okay, so if you work with crypto, you know the drill: hopping between dashboards, opening browser tabs just to check a balance, or manually fetching historical price points for an analysis. That whole process is slow and it introduces friction—and bad data can cost real money.
This MCP cuts that out entirely. It connects your agent directly to Kraken's API endpoints, so you don't need external logins or multiple screens. You simply ask your AI client for what you need—like the current price of ETH/USD and a summary of your available funds—and it runs the query itself.
This Vinkius catalog connector handles everything from fetching granular asset pair information to running complex order book analysis (for futures trading). It just makes data retrieval conversational.
019e5d2c-009c-708b-b99a-b592b24b4f54 Here's how it actually works
The bottom line is that your AI client handles all the API calls; you just type what you want to know or do.
First, subscribe to this MCP and provide your required Kraken API Key and Secret; (this is necessary because the tool needs authenticated access).
Next, prompt your AI client with a specific request—for example, 'What's the 24-hour volume for BTC/USD?'
The agent executes the appropriate function call through this MCP, retrieves the raw market data, and formats it back to you in plain text.
Who is this actually for?
This MCP is for anyone who spends time in crypto trading, but especially for quantitative analysts and developers. If you’re tired of building fragile scripts that require hardcoded API endpoints, this is what you need.
Pulling historical OHLC data or querying the full order book depth to run backtests without leaving their main analysis environment.
Testing market data queries and monitoring system status straight from a coding environment, ensuring API reliability before deployment.
Quickly checking current spot balances or listing open orders without having to switch to the Kraken website's dashboard.
What Changes When You Connect
Check account balances instantly. Instead of navigating to a separate 'Balances' tab, you just ask for it; the agent runs spot_get_balance immediately.
Track full trading activity. You can get both recent trades (spot_get_trades) and a deep history (spot_get_trades_history), all without switching applications.
Run complex market simulations. Pulling historical OHLC data via spot_get_ohlc lets you model price action directly in your agent's workspace, which is way faster than CSV exports.
Execute trades and manage risk from one prompt. You can use spot_add_order to place a bet, or immediately follow up with spot_cancel_order if the market shifts unexpectedly.
View system health on demand. Use spot_get_system_status to confirm that Kraken is actually operational before running any high-stakes query (a necessary sanity check).
Understand liquidity depth. Accessing the order book (spot_get_depth) lets you see exactly where the current buy and sell pressure lies, which is critical for serious trading.
See it in action
Need to compare spot vs. futures risk.
A user needs to model a potential trade; they ask their agent to check the spot_get_balance first, then use futures_get_orderbook for pricing depth, and finally execute a hypothetical order using futures_send_order. The whole sequence happens in one chat session.
Investigating why an old trade failed.
The user asks the agent to check their account status. The agent executes spot_get_ledgers, providing a granular, transaction-by-transaction report that pinpoints exactly where the funds went wrong.
Performing rapid market analysis.
A financial analyst needs quick data points for a presentation. They use the agent to call spot_get_ticker multiple times, gathering real-time prices and calculating spreads using spot_get_spread, all in under a minute.
Cleaning up old test orders.
A developer finishes testing a pair of assets. They use the agent to call spot_query_orders to find all relevant IDs, then run spot_cancel_all_orders_after on the test date, ensuring nothing is left open.
The honest tradeoffs
Treating it like a database query
Trying to manually format prompts like 'SELECT * FROM trades WHERE type=spot AND date > 2024-01-01' because the agent can't handle SQL.
Just ask: 'Show me all recent trade history for BTC/USD.' The agent knows it needs to call spot_get_trades_history and handles the necessary formatting. It's natural language, not SQL.
Ignoring market type differences
Running a spot balance check (spot_get_balance) when you actually need to see your futures margin collateral.
If the trade is related to derivatives or futures, make sure you reference 'futures' in your prompt. The agent knows to look at tools like futures_get_orderbook instead of spot ones.
Copying/pasting API responses
Getting a massive JSON blob from the agent and having to copy-paste it into Excel, losing context in the process.
Ask the agent to interpret the data. Say: 'Based on these open orders, what's our current risk profile?' The agent does the calculation after retrieving the data.
When It Fits, When It Doesn't
Use this MCP if your primary need is real-time, authenticated crypto market and account data retrieval; it handles both simple balance checks (spot_get_balance) and complex functions like order book depth or historical OHLC analysis. Don't use it if you are trying to analyze external datasets (e.g., macroeconomic reports) or if you just need a generic list of APIs—use those specialized tools instead. If you only need to read data, the spot/futures query tools suffice; but if you need to act on that data (placing orders), then this MCP is necessary.
Questions you might have
How do I get historical price data using spot_get_ohlc? +
You just ask the agent for it. You don't need to manually construct endpoints or worry about date formats; tell it the asset and time frame, and spot_get_ohlc handles the rest.
Can I use futures_send_order with this MCP? +
Yes. You can send orders for futures contracts using futures_send_order. This keeps your spot and derivatives trading actions organized in one place, which is pretty convenient.
What's the difference between spot_get_depth and spot_get_ohlc? +
spot_get_depth shows you the immediate buy/sell pressure (the current order book), while spot_get_ohlc gives you historical price points over time, which is better for charting.
Is there a tool to check if my account has money? +
Yes. Use spot_get_balance or spot_get_trade_balance. They both give you the current cash availability, but one is more generalized than the other.
How do I list all my orders? +
You can use spot_query_orders to get a comprehensive overview of your order status, or if you just want active ones, use spot_get_open_orders.
What should I use with `spot_get_system_status` to confirm optimal trading conditions? +
You use this tool to verify the operational readiness of Kraken. It checks core system metrics, ensuring that the platform is running normally and that time synchronization is accurate for your trades.
How do I discover all available assets and pairs using `spot_get_asset_pairs`? +
The tool returns a comprehensive list of every asset pair currently tradable on the spot market. Use this output to select the specific symbols you need before attempting any price or order book queries.
If I need detailed financial records, how do I check my movement history using `spot_get_ledgers`? +
This function retrieves a complete audit log of your account movements. Unlike trade history, ledgers detail deposits, withdrawals, and fee structures, giving you a full accounting view.
How can I check the current price of Bitcoin against USD? +
You can use the spot_get_ticker tool. Simply provide the asset pair, such as {"pair": "XXBTZUSD"}, and the agent will return the latest bid, ask, and last trade prices.
Is it possible to see my total account balance across all currencies? +
Yes! The spot_get_balance tool retrieves your full account balance. Your AI agent will list each asset you hold and its corresponding amount.
Can I monitor my active limit orders using this server? +
Absolutely. Use the spot_get_open_orders tool to fetch a list of all currently active orders, including their status, volume, and price details.
We've already built the connector for Kraken. Just plug in your AI agents and start using Vinkius.
No hosting. No infrastructure. No complex setup.
All 28 tools are live and waiting.
You're up and running in seconds.
Vinkius gives your AI agents access to the full catalog of app connectors, all fully managed, secure, and enterprise-ready. One subscription, every tool you need.
Built, hosted, and secured by Vinkius. You just connect and go.