Connect HashKey to Claude: Manage Asset Balances and Futures Risk

If you need to connect HashKey to Claude to automate crypto trading, manage futures leverage risk, or orchestrate high-volume asset transfers, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's LLM function calls and HashKey's REST and WebSocket APIs. You can either build and maintain this infrastructure yourself, or use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL. If your team uses ChatGPT, check out our guide on connecting HashKey to ChatGPT or explore our broader architectural overview on connecting HashKey to AI Agents.

Giving a Large Language Model (LLM) read and write access to a sprawling financial exchange like HashKey is a massive engineering challenge. You have to handle fragmented account models, map massive JSON schemas for order books to MCP tool definitions, and deal with strict financial rate limits. Every time HashKey updates a withdrawal parameter or deprecates a margin field, you have to update your server code, redeploy, and test the integration.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for HashKey, connect it natively to Claude Desktop, and execute complex quantitative workflows using natural language.

The Engineering Reality of the HashKey API

A custom MCP server is a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover tools, the reality of implementing it against HashKey's API is painful. You are not just integrating a standard CRUD application - you are integrating highly volatile spot markets, futures risk engines, and strict digital asset compliance systems.

If you decide to build a custom MCP server for HashKey, you own the entire API lifecycle. Here are the specific challenges you will face:

Complex Withdrawal Whitelisting and Cryptographic Signatures Unlike generic SaaS APIs, moving capital out of HashKey requires strict cryptographic validation. You cannot simply call a POST /withdraw endpoint. HashKey enforces a whitelisting process that demands either a signature challenge (create_a_hash_key_whitelist_wallet_signing) or a micropayment verification process. To verify a wallet, the API forces you to generate a specific micropayment deposit address, transfer a highly specific fractional amount of a coin on a specific chain, and validate the transaction. Exposing this multi-step, stateful process to an LLM directly often results in hallucinations, as the model attempts to skip steps or fabricate transaction hashes.

Fragmented Order Schemas Across Spot and Futures HashKey does not use a unified order schema. A spot market limit order and a futures perpetual contract stop-loss require completely different payloads, enumerations, and time-in-force parameters. If you expose the raw HashKey endpoints to Claude without explicit, bounded JSON schemas, the model will frequently mix up spot order types (like LIMIT vs MARKET) with futures price types (like INPUT vs OPPONENT). Truto handles this by dynamically generating distinct MCP tools with explicit, constrained JSON schemas derived directly from HashKey's official documentation, ensuring Claude knows exactly which fields belong to which market type.

Strict Rate Limiting and Financial Data Quotas HashKey enforces stringent rate limits, particularly on order book depth, tick data, and historical funding rates. When you give an AI agent access to fetch historical Kline data to analyze market trends, it can easily exhaust your IP or account limits in seconds.

It is critical to understand how this is handled in a managed environment: Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream HashKey API returns an HTTP 429 Too Many Requests, Truto passes that error directly to the caller. However, Truto normalizes the upstream rate limit information into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF specification. The caller (your MCP client or AI agent infrastructure) is entirely responsible for reading these standardized headers and implementing appropriate retry and exponential backoff logic. Do not expect the integration layer to absorb market data throttling on your behalf.

How to Generate a HashKey MCP Server with Truto

Truto's dynamic tool generation derives MCP tools directly from HashKey's resource definitions and schema documentation. A tool only appears in your MCP server if it has a corresponding documentation entry - ensuring LLMs only access well-curated, documented endpoints.

Each MCP server is scoped to a single integrated account (your specific connected HashKey instance) and authenticated via a cryptographic token URL. You can generate this server in two ways.

Method 1: Via the Truto UI

For administrators and operators, the easiest way to generate a server is through the dashboard:

1. Navigate to the Integrated Accounts page in your Truto dashboard and select your HashKey connection.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration. You can limit access to read-only methods, filter by specific tags (like futures or spot), and set an automatic expiration date.
5. Click Save and copy the generated MCP server URL (e.g., https://api.truto.one/mcp/a1b2c3d4...).

Method 2: Via the API

For engineering teams building programmatic agent infrastructure, you can generate MCP servers on the fly via the REST API. This is ideal for generating short-lived, tightly scoped servers for temporary quantitative analysis sessions.

Make a POST request to /integrated-account/:id/mcp:

const response = await fetch('https://api.truto.one/api/integrated-account/YOUR_HASHKEY_ACCOUNT_ID/mcp', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_TRUTO_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    name: "HashKey Futures Risk Agent",
    config: {
      methods: ["read", "update"], // Allow fetching positions and updating leverage
      tags: ["futures", "market_data"] // Restrict to futures and market data operations
    },
    expires_at: "2026-12-31T23:59:59Z" // Auto-revoke access at year end
  })
});
 
const mcpServer = await response.json();
console.log(mcpServer.url); // The endpoint to pass to Claude

Under the hood, Truto hashes the token for secure storage in a distributed key-value store, registers a scheduled durable alarm for automatic cleanup upon expiration, and instantly exposes the filtered HashKey tools over a JSON-RPC 2.0 interface.

Connecting the MCP Server to Claude

Once you have the Truto MCP server URL, connecting it to Anthropic's ecosystem requires zero additional engineering.

Method A: Via the Claude UI

If you are using Claude's enterprise or team web interfaces (or ChatGPT's Custom Connectors):

1. Open your Claude settings and navigate to Integrations (or Connectors in the Claude Desktop app).
2. Click Add MCP Server.
3. Paste the Truto MCP URL (https://api.truto.one/mcp/...).
4. Click Add. Claude will immediately perform a protocol handshake, pull the JSON schemas for the HashKey tools, and make them available to the model.

Method B: Via Manual Config File

If you are configuring Claude Desktop manually for local agent development, you need to update your claude_desktop_config.json file. Because Truto's MCP servers communicate over HTTP, you will use an SSE (Server-Sent Events) bridge client to connect Claude's standard I/O to the remote Truto URL.

{
  "mcpServers": {
    "hashkey_production": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "https://api.truto.one/mcp/YOUR_SECURE_TOKEN"
      ]
    }
  }
}

Restart Claude Desktop. The model now has real-time read and write access to your HashKey environment.

HashKey Hero Tools for Claude

Truto automatically translates HashKey's REST endpoints into AI-ready tools. The JSON schemas instruct Claude exactly which fields are required, which are optional, and what enumerations are permitted. Here are the highest-leverage tools available for your agents.

hash_key_account_get_account_info

Retrieve comprehensive account balances across all digital and fiat assets. This is the foundational tool for any agent that needs to verify capital availability before executing trades or withdrawals.

"Claude, check my HashKey account balances. What is my total available USDT and ETH across both main and sub-accounts?"

hash_key_futures_get_positions

List all open futures positions in HashKey. This tool allows the agent to monitor exposure, entry prices, and liquidation thresholds across perpetual contracts.

"Fetch my current futures positions on the BTCUSDT-PERPETUAL contract. Calculate my current unrealized PnL and tell me how close I am to the liquidation price."

hash_key_futures_set_leverage

Modify the leverage multiplier for a specific futures contract. This is critical for automated risk management workflows where an agent dynamically deleverages a position during periods of high volatility.

"The market is exhibiting extreme volatility. Reduce the leverage on my active ETHUSDT-PERPETUAL short position down to 3x immediately."

create_a_hash_key_spot_order

Execute a spot trade on HashKey Exchange. The tool enforces the required parameters for side (BUY/SELL), type (LIMIT/MARKET), and quantity, ringing fencing funds automatically during execution.

"Place a limit buy order for 0.5 BTC on the BTC/USDT pair at a price of 64,500. Ensure the order is set as Good-Till-Canceled."

create_a_hash_key_account_withdraw

Submit a digital asset withdrawal request. Note that HashKey strictly requires the destination address to be whitelisted prior to execution. Claude will be blocked if it attempts to withdraw to an unknown address.

"Initiate a withdrawal of 5,000 USDC over the ERC20 chain to our pre-whitelisted corporate treasury wallet. Provide me with the transaction order ID once submitted."

hash_key_market_data_get_klines

Pull historical candlestick (Kline) data for a specific trading pair. Agents use this to perform moving average calculations, identify support/resistance levels, and generate technical analysis briefs.

"Get the 1-hour Kline data for SOL/USDT over the last 24 hours. Analyze the volume spikes and tell me if there is a bullish divergence forming."

To view the complete inventory of available HashKey tools, parameters, and schemas, visit the Truto HashKey integration page.

Workflows in Action

Once connected, Claude can orchestrate multi-step financial operations by combining these tools into autonomous workflows.

Scenario 1: Quantitative Trader Managing Futures Risk

An algorithmic trading desk wants to use Claude to monitor weekend volatility and autonomously de-risk their portfolio if certain drawdown conditions are met.

"Analyze my open BTCUSDT-PERPETUAL positions. If my unrealized PnL is negative and the current mark price is within 5% of my liquidation price, reduce my leverage to 2x to free up margin."

Execution sequence:

1. Claude calls hash_key_futures_get_positions to check entry price, leverage, and margin.
2. Claude calls hash_key_market_data_get_mark_price for BTCUSDT-PERPETUAL to get real-time pricing.
3. The model calculates the percentage difference between the mark price and liquidation price.
4. Identifying the threshold is breached, Claude calls hash_key_futures_set_leverage passing leverage: 2 to mitigate risk.

sequenceDiagram
    participant Claude as Claude Desktop
    participant Truto as Truto MCP Server
    participant HashKey as HashKey API
    Claude->>Truto: Call hash_key_futures_get_positions
    Truto->>HashKey: GET /api/v1/futures/positions
    HashKey-->>Truto: Return positions & margins
    Truto-->>Claude: Standardized JSON
    Claude->>Truto: Call hash_key_market_data_get_mark_price
    Truto->>HashKey: GET /api/v1/futures/markPrice
    HashKey-->>Truto: 200 OK (Price Data)
    Truto-->>Claude: Standardized JSON
    Claude->>Truto: Call hash_key_futures_set_leverage (2x)
    Truto->>HashKey: POST /api/v1/futures/leverage
    HashKey-->>Truto: 200 OK (Leverage Updated)
    Truto-->>Claude: Success Confirmation

Scenario 2: Treasury Manager Automating Sweep Operations

A corporate treasury team uses Claude to sweep excess capital off the exchange into cold storage at the end of the trading week.

"Check our USDT spot balance. If the available balance is above 100,000, initiate a withdrawal of 50,000 to our whitelisted cold wallet address on the TRC20 network."

Execution sequence:

1. Claude calls hash_key_account_get_account_info to inspect asset balances.
2. The model isolates the USDT balance array and verifies the available amount is > 100,000.
3. Claude calls hash_key_wallet_get_whitelisted_address to verify the destination wallet ID exists and is approved for TRC20.
4. Claude executes create_a_hash_key_account_withdraw for 50,000 USDT to the verified address and reports the orderId back to the user.

Security and Access Control

Giving an LLM access to a financial exchange requires strict security boundaries. Truto's MCP architecture enforces control at the server level, ensuring Claude can never exceed its mandate.

• Method Filtering: Restrict servers to specific operation types. You can create a read-only server (methods: ["read"]) that allows Claude to query balances and market data, but physically blocks it from executing trades (create, update, delete).
• Tag Filtering: Limit the server's domain footprint. By passing tags: ["market_data"], the generated MCP server will entirely exclude account, wallet, and trading tools, keeping the AI agent strictly focused on market analysis.
• Dual-Layer Authentication: By enabling require_api_token_auth: true, possession of the MCP URL is no longer sufficient to access the tools. The client must also pass a valid Truto API token in the Authorization header, ensuring only authenticated personnel can utilize the AI agent.
• Ephemeral Servers: Use the expires_at property to grant Claude temporary access. Once the ISO datetime is reached, the distributed key-value entries are instantly revoked, and cleanup alarms wipe the server from existence - perfect for temporary auditing sessions.

Automating digital asset management requires an integration layer that respects the complexity of financial APIs. Stop hand-coding complex websocket listen key lifecycles and wrestling with fragmented futures schemas. Truto normalizes HashKey's infrastructure, allowing you to instantly deploy secure, curated MCP servers to Claude and focus entirely on your trading logic.

:::cta{buttonText="Talk to us" buttonUrl="https://cal.com/truto/partner-with-truto"} Let's talk about building secure AI agent workflows for your financial infrastructure. :::