Connect HashKey to AI Agents: Automate Global Transfers and Earn

You want to connect HashKey to an AI agent so your internal systems can independently analyze market depth, automate global transfers, execute spot and futures trades, and allocate idle funds to earn products based on market signals. Here is exactly how to do it using Truto's /tools endpoint and SDK, bypassing the need to manually build, authenticate, and maintain complex exchange API wrappers.

Giving a Large Language Model (LLM) read and write access to your HashKey exchange environment is an engineering headache. You either spend weeks building and maintaining a custom connector that handles strict exchange authentication, pagination, and data schemas, or you use a managed infrastructure layer that provides agent-ready tools out of the box. If your team uses ChatGPT, check out our guide on connecting HashKey to ChatGPT, or if you are building on Anthropic's models, read our guide on connecting HashKey to Claude. For developers building custom autonomous workflows, you need a programmatic way to fetch these tools and bind them to your agent framework.

This guide breaks down exactly how to fetch AI-ready tools for HashKey, bind them natively to an LLM using LangChain (or frameworks like LangGraph, CrewAI, or Vercel AI SDK), and execute complex treasury and trading operations workflows. For a deeper look at the architecture behind this approach, refer to our research on architecting AI agents and the SaaS integration bottleneck.

The Engineering Reality of Custom HashKey Connectors

Building AI agents is easy. Connecting them to external financial APIs is hard. Giving an LLM access to external exchange data sounds simple in a prototype. You write a Node.js function that makes a fetch request, wrap it in an @tool decorator, and move on. In production, this approach collapses entirely, especially with an ecosystem as secure and complex as HashKey.

If you decide to build this integration yourself, you own the entire API lifecycle. HashKey's API introduces several highly specific integration challenges that break standard LLM assumptions.

The Whitelisting and Withdrawal Trap

Unlike standard SaaS APIs where an agent can simply POST a payload to transfer assets, HashKey enforces rigorous security controls around withdrawals. An agent cannot simply hallucinate a destination address and execute a withdrawal. The withdrawal address must be whitelisted in advance.

If the agent needs to whitelist an address programmatically, it cannot just hit a single endpoint. It must navigate a complex challenge - either initiating a micropayment deposit address verification (list_all_hash_key_whitelist_verifies) or a wallet signing verification (create_a_hash_key_whitelist_wallet_signing). If you hand-code this integration, you have to write complex prompts to teach the LLM exactly how to handle signature phrases, chain types (e.g., Optimism vs Arbitrum for ETH), and withdrawal flows. When the LLM inevitably hallucinates a chain type or fails to pass the correct 2FA parameters, your automated treasury workflow halts.

Precision, Concentration Limits, and Market Data

Financial APIs do not tolerate rounding errors or invalid symbol formats. If an agent wants to place a spot order, it cannot just ask to "Buy 100 dollars of Bitcoin." It must know the exact symbol format, the priceType, the timeInForce, and respect the exact tick size and lot size precision required by the exchange matching engine.

Retrieving this metadata requires querying hash_key_market_data_get_exchange_info and injecting the results back into the agent's context. A direct API tool approach pushes all these exchange-specific data structures into the LLM's context window. The model has to remember the exact JSON schema required for batch futures orders versus standard spot orders. Every one of those quirks is a hallucination waiting to happen.

The Unified Tool Layer Approach

Before writing a line of integration code, decide what layer your agent talks to. A unified tool layer collapses complex API schemas into strict, deterministic JSON schemas. Your agent sees create_a_hash_key_spot_order or hash_key_futures_modify_position_margin with clearly defined parameters.

That gives you concrete safety wins:

1. Deterministic input validation. Every tool has a strict JSON schema. Invalid arguments (like an unsupported chainType) are rejected before they hit the exchange API, so a broken tool call fails fast.
2. Smaller attack surface. The LLM only ever chooses from stable function names and inputs. It never invents API paths or authentication headers.
3. Decoupled authentication. The agent does not need to know how to construct HashKey's highly specific HMAC SHA256 signatures or timestamp headers. The infrastructure layer handles authentication transparently.

Hero Tools for HashKey AI Agents

Truto provides a comprehensive suite of tools for HashKey, translating the underlying REST API into agent-ready functions. Here are the highest-leverage operations for building automated treasury and trading agents.

Get Exchange Info

Before your agent can trade, it needs to understand the rules of the road. This tool fetches current exchange trading rules and symbol information, including maker/taker fees, product types, and allowed quote currencies.

Tool Name: hash_key_market_data_get_exchange_info

Usage Notes: Agents should call this tool when initializing a new trading pair to understand the exact string format required (e.g., BTCUSDT) and to calculate expected fee deductions before placing orders.

"Fetch the current exchange info and trading rules for all symbols. Filter the response to find the exact symbol format and taker fee rate for trading Ethereum against USDT."

Create a Spot Order

This tool allows the agent to execute a single spot order on the HashKey Exchange. Required funds are ringfenced for the duration of the order.

Tool Name: create_a_hash_key_spot_order

Usage Notes: Requires symbol, side, type, and quantity. Agents must parse market data first to ensure the requested quantity aligns with the exchange's lot size rules.

"Place a market buy order for 0.05 BTCUSDT. Ensure you specify the correct order side and type. Return the resulting orderId and executedQty."

Internal Account Transfers

For enterprise setups with master and sub-accounts, managing capital efficiency is critical. This tool transfers assets internally between HashKey accounts instantly.

Tool Name: hash_key_account_internal_transfer

Usage Notes: Requires fromAccountId, toAccountId, coin, and quantity. This is heavily used by routing agents that rebalance portfolios across different trading strategies running in isolated sub-accounts.

"Transfer 50,000 USDT from the master treasury account to sub-account 847291 to fund the new algorithmic trading strategy."

Modify Futures Position Margin

Managing liquidation risk is a primary use case for autonomous agents. This tool modifies the isolated position margin for a HashKey futures contract, allowing the agent to dynamically increase or decrease margin based on market volatility.

Tool Name: hash_key_futures_modify_position_margin

Usage Notes: Requires symbol, side, and amount. A positive amount increases the margin, while a negative amount decreases it.

"The mark price for BTCUSDT-PERPETUAL has dropped 5%. Increase the isolated position margin for our long position by 10,000 USDT to prevent liquidation."

Subscribe to Earn Products

Idle capital is wasted capital. This tool allows the agent to automatically allocate idle assets into HashKey's standard or staking earn products.

Tool Name: hash_key_earn_purchase

Usage Notes: Requires productId, currency, amount, and a client-defined clOrderId. The agent typically queries available offers first using the hash_key_earn_get_offers tool to find the optimal APY.

"Review the available staking products for ETH. If there is a product offering greater than 4% APY, subscribe 15 ETH from the main account into that product."

Get Deposit Address

This tool retrieves the system-generated deposit address for a specific asset and chain, enabling the agent to orchestrate inbound transfers from external wallets or other exchanges.

Tool Name: hash_key_wallet_get_deposit_address

Usage Notes: Requires coin and chainType. The agent must ensure it specifies the correct chain (e.g., ERC20 vs TRC20) to avoid lost funds.

"Generate a deposit address for USDC on the Ethereum network (ERC20). Return the address and any required memo fields so I can initiate the inbound transfer."

To view the complete inventory of available endpoints and their exact JSON schemas, visit the HashKey integration page.

Workflows in Action

When you equip an LLM with these tools, you move beyond basic chat interfaces into autonomous financial operations. Here are three concrete workflows you can build today.

1. The Autonomous Treasury Manager

Corporate treasuries often leave idle stablecoins sitting in main accounts. An AI agent can monitor balances and automatically sweep idle funds into yield-bearing products.

"Check the main account balance for idle USDT. If the balance exceeds 100,000 USDT, find the best available standard earn product and allocate 80% of the idle balance to it."

Execution Steps:

1. The agent calls hash_key_account_get_account_info to retrieve current balances across all assets.
2. It identifies 150,000 USDT sitting idle.
3. The agent calls hash_key_earn_get_offers and filters for USDT standard products, finding a 7-day fixed product offering 5% APY.
4. The agent calculates 80% of 150,000 (120,000 USDT).
5. The agent calls hash_key_earn_purchase with the specific productId and amount.
6. Result: The user receives a summary confirming the successful allocation and the expected yield generation.

2. Algorithmic Risk Management

Managing isolated margin on futures positions requires constant vigilance. An agent can operate as a 24/7 risk manager, topping up margins during flash crashes.

"Review all open futures positions. If any long position is within 5% of its liquidation price based on the current mark price, transfer funds from the spot account and increase the position margin to restore a 15% buffer."

Execution Steps:

1. The agent calls hash_key_futures_get_positions to list all active positions.
2. It calls hash_key_market_data_get_mark_price to fetch current market pricing for the relevant symbols.
3. It calculates the risk delta. If a position is near liquidation, it calls hash_key_account_get_account_info to verify available spot balances.
4. It calls hash_key_futures_modify_position_margin to inject additional USDT into the endangered isolated position.
5. Result: The user receives a critical alert detailing the risk intervention and the exact amount of margin added to the position.

3. Cross-Exchange Arbitrage Setup

To capture arbitrage opportunities, capital must move quickly. An agent can prepare the accounts by checking whitelisted addresses and generating required deposit info.

"We need to move 50 ETH to HashKey for a spot arbitrage trade. Check if our external cold wallet is whitelisted for withdrawals, and get the HashKey Ethereum deposit address so we can route the funds."

Execution Steps:

1. The agent calls hash_key_wallet_get_whitelisted_address to verify the external cold wallet is approved for future outbound flows.
2. It calls hash_key_wallet_get_chain_type to confirm the exact chain identifier HashKey expects for Ethereum (e.g., ETH).
3. It calls hash_key_wallet_get_deposit_address passing coin: "ETH" and chainType: "ETH".
4. Result: The user receives the verified deposit address, knowing the return path to cold storage is already whitelisted and ready.

Building Multi-Step Workflows

To build these autonomous loops, you need an orchestration framework. LangChain, LangGraph, and Vercel AI SDK all support tool calling. By using Truto's /tools endpoint, you dynamically load the API schema into your agent.

Factual Note on Rate Limits

When writing automated trading loops, rate limits are a reality. Truto does not retry, throttle, or apply backoff on rate limit errors. If your agent hits HashKey's API limits and the upstream API returns an HTTP 429, Truto passes that exact error directly to your caller.

Truto normalizes the upstream rate limit information into standardized headers per the IETF spec:

• ratelimit-limit
• ratelimit-remaining
• ratelimit-reset

Your application code - not Truto - is responsible for inspecting these headers, implementing exponential backoff, and retrying the tool call. Do not assume the infrastructure will magically absorb 429s.

Tool Execution Architecture

Here is how the request lifecycle flows when an agent decides to execute a trade:

sequenceDiagram
    participant App as Your AI App
    participant LLM as LLM (OpenAI/Anthropic)
    participant Truto as Truto ToolManager
    participant Upstream as HashKey API

    App->>Truto: Fetch HashKey Tools via /tools
    Truto-->>App: Return JSON Schemas (Create Spot Order, etc.)
    App->>LLM: bindTools() and Send User Prompt
    LLM-->>App: tool_call (create_a_hash_key_spot_order)
    App->>Truto: Execute Tool Call with args
    Truto->>Upstream: Authenticated API Request
    alt Rate Limit Hit
        Upstream-->>Truto: 429 Too Many Requests
        Truto-->>App: 429 Error + ratelimit-reset Header
        App->>App: Sleep until ratelimit-reset
        App->>Truto: Retry Tool Call
        Truto->>Upstream: Authenticated API Request
    end
    Upstream-->>Truto: 200 OK (Order ID)
    Truto-->>App: Tool Execution Result
    App->>LLM: Return Tool Result
    LLM-->>App: Final Natural Language Response

Implementation Example (LangChain.js)

Below is a conceptual example of how to fetch these tools, bind them to a model, and execute a multi-step treasury operation while explicitly handling potential rate limits. We use the TrutoToolManager from the truto-langchainjs-toolset.

import { ChatOpenAI } from "@langchain/openai";
import { HumanMessage } from "@langchain/core/messages";
import { TrutoToolManager } from "truto-langchainjs-toolset";
 
async function runHashKeyTreasuryAgent() {
  // 1. Initialize the Truto Tool Manager with your HashKey integration ID
  const toolManager = new TrutoToolManager({
    integratedAccountId: process.env.HASHKEY_ACCOUNT_ID,
    trutoApiKey: process.env.TRUTO_API_KEY,
  });
 
  // 2. Fetch the tools dynamically from Truto's /tools endpoint
  console.log("Fetching HashKey tools...");
  const tools = await toolManager.getTools();
  
  // 3. Initialize the LLM and bind the tools natively
  const llm = new ChatOpenAI({
    modelName: "gpt-4o",
    temperature: 0,
  }).bindTools(tools);
 
  // 4. Define the complex, multi-step user prompt
  const messages = [
    new HumanMessage("Check my main account balance. If I have more than 50,000 USDT idle, transfer 10,000 USDT to sub-account 99281, and put the rest into a standard Earn product.")
  ];
 
  console.log("Starting agent loop...");
 
  // 5. The Agent Loop
  while (true) {
    const response = await llm.invoke(messages);
    messages.push(response);
 
    // If the LLM doesn't want to call a tool, we are done.
    if (!response.tool_calls || response.tool_calls.length === 0) {
      console.log("Agent finished:", response.content);
      break;
    }
 
    // 6. Execute the tool calls
    for (const toolCall of response.tool_calls) {
      console.log(`Executing tool: ${toolCall.name}`);
      
      let toolResult;
      let retries = 3;
      
      while (retries > 0) {
        try {
          // Truto executes the authenticated request to HashKey
          const tool = tools.find((t) => t.name === toolCall.name);
          toolResult = await tool.invoke(toolCall.args);
          break; // Success, exit retry loop
        } catch (error) {
          // Explicit Rate Limit Handling
          if (error.response && error.response.status === 429) {
            const resetTime = error.response.headers['ratelimit-reset'];
            console.warn(`Rate limit hit. Waiting until ${resetTime}...`);
            
            // Calculate sleep time based on the standardized IETF header
            const sleepMs = (new Date(resetTime).getTime() - Date.now()) + 1000;
            await new Promise(resolve => setTimeout(resolve, Math.max(sleepMs, 1000)));
            
            retries--;
          } else {
            // Bubble up non-429 errors (e.g. invalid permissions, bad parameters)
            throw error;
          }
        }
      }
 
      // Pass the result back into the agent's context window
      messages.push({
        role: "tool",
        tool_call_id: toolCall.id,
        name: toolCall.name,
        content: JSON.stringify(toolResult),
      });
    }
  }
}
 
runHashKeyTreasuryAgent().catch(console.error);

This architecture is inherently stable. If HashKey adds a new required parameter to their spot order endpoint, you do not need to redeploy your AI agent. Truto's /tools endpoint automatically updates the JSON schema, the LLM reads the new schema on its next initialization, and the agent adapts its behavior dynamically.

Moving Beyond Manual Exchange Integration

Building AI agents that interact with crypto exchanges requires extreme precision. Financial APIs are unforgiving. By using a unified tool layer, you remove the burden of auth management, signature generation, and endpoint maintenance from your engineering team.

Your developers can focus on building sophisticated treasury algorithms, risk management rules, and user experiences, rather than parsing documentation to figure out exactly how HashKey formats its HMAC hashes or handles pagination tokens.