--- title: "Connect HashKey to AI Agents: Automate Global Transfers and Earn" slug: connect-hashkey-to-ai-agents-automate-global-transfers-and-earn date: 2026-08-07 author: Riya Sethi categories: ["AI & Agents"] excerpt: "Learn how to connect HashKey to AI agents using Truto's /tools endpoint. Automate global transfers, spot orders, and futures risk management with working code." tldr: "Connect HashKey to AI agents to automate global transfers, spot orders, and futures risk management. This guide covers HashKey's API quirks, tool calling via Truto, and multi-step agent workflows." canonical: https://truto.one/blog/connect-hashkey-to-ai-agents-automate-global-transfers-and-earn/ --- # 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](https://truto.one/connect-hashkey-to-chatgpt-analyze-market-data-and-execute-trades/), automate global transfers, execute [spot and futures trades](https://truto.one/connect-hashkey-to-chatgpt-analyze-market-data-and-execute-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](https://truto.one/connect-hashkey-to-chatgpt-analyze-market-data-and-execute-trades/), or if you are building on Anthropic's models, read our guide on [connecting HashKey to Claude](https://truto.one/connect-hashkey-to-claude-manage-asset-balances-and-futures-risk/). 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](https://truto.one/architecting-ai-agents-langgraph-langchain-and-the-saas-integration-bottleneck/), 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](https://truto.one/architecting-ai-agents-langgraph-langchain-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](https://truto.one/connect-hashkey-to-claude-manage-asset-balances-and-futures-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](https://truto.one/integrations/detail/hashkey). ## 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: ```mermaid 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`. ```typescript 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. > Stop wasting engineering cycles building custom exchange connectors. Let Truto handle the integration layer so your team can focus on building intelligent, autonomous trading agents. > > [Talk to us](https://cal.com/truto/partner-with-truto)