Connect Depasify to Claude: Automate Crypto Payments & Trading

If you need to connect Depasify to Claude to automate crypto payouts, manage KYB onboarding, or orchestrate high-volume trading workflows, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's tool calling capabilities and Depasify's specialized REST 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 Depasify to ChatGPT or explore our broader architectural overview on connecting Depasify to AI Agents.

Giving a Large Language Model (LLM) read and write access to a sprawling financial orchestration platform like Depasify is an engineering challenge. You have to handle session tokens, map complex multi-part document schemas to MCP tool definitions, and deal with strict financial compliance requirements. Every time Depasify updates an endpoint or alters a KYC requirement, 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 Depasify, connect it natively to Claude Desktop, and execute complex crypto and fiat workflows using natural language.

The Engineering Reality of the Depasify 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 Depasify's API requires dealing with specific financial orchestration quirks.

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

Asynchronous Four-Eyes Policy State Management Many Depasify endpoints, particularly FiatPayments and BlockchainPayments, operate under a strict "four eyes" policy. When an LLM calls an endpoint to execute a transfer, the API does not simply return a success state. It returns a pending_approval status. A custom MCP server must implement logic to either poll for state changes or expose secondary approval tools so that another authorized user (or agent) can complete the transaction. Exposing these dual-approval mechanics to an LLM requires explicit schema instructions so the model understands why a payment has not yet settled.

Multi-Step KYB Document Uploads Onboarding a business (KYB) in Depasify is not a single POST request. You must first create the KYB application to generate a unique UUID, then sequentially upload individual identification documents to specific attributes on that KYB record, and finally submit the application. Standard REST wrappers struggle with multi-part file uploads initiated by text models. Your MCP server must translate Base64 encoded document streams from the LLM into Depasify's specific binary upload constraints.

Strict Rate Limiting Transparency Depasify applies specific rate limits to high-frequency endpoints like market data pricing and ledger queries. If an AI agent gets caught in a loop querying order book depth, it will quickly exhaust these limits. Truto does not retry, throttle, or apply backoff on rate limit errors. When Depasify returns an HTTP 429, Truto passes that error directly to the caller. Truto normalizes the upstream rate limit information into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF specification. Your agent implementation is strictly responsible for handling the 429 response and applying its own backoff logic.

How to Generate a Depasify MCP Server with Truto

Truto dynamically generates MCP tools from its underlying integration configurations and documentation records. When you provision an MCP server for Depasify, Truto evaluates the available API endpoints, parses the query and body schemas, and exposes them as a JSON-RPC 2.0 endpoint.

You can create this server in two ways: via the Truto UI for manual configuration, or via the API for programmatic agent provisioning.

Method 1: Via the Truto UI

If you are setting up Claude Desktop for internal operations, the UI is the fastest path.

1. Navigate to the Integrated Accounts page in your Truto dashboard and select your connected Depasify account.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Configure your server. You can limit the agent to read operations to prevent accidental trades, or scope it to specific tags like payments or kyc.
5. Click Create and copy the generated MCP server URL (e.g., https://api.truto.one/mcp/a1b2c3d4e5f6...).

Method 2: Via the Truto API

If you are dynamically provisioning AI agents for your end-users, you can generate MCP servers programmatically. The Truto API validates the integration configuration, generates a cryptographically hashed token stored in edge storage, and returns a ready-to-use URL.

curl -X POST https://api.truto.one/integrated-account/{integrated_account_id}/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Claude Depasify Trading Agent",
    "config": {
      "methods": ["read", "write"],
      "tags": ["trades", "market_data", "blockchain_wallets"]
    },
    "expires_at": "2026-12-31T23:59:59Z"
  }'

The response contains the exact URL you will provide to your MCP client.

{
  "id": "mcp_srv_9x8y7z",
  "name": "Claude Depasify Trading Agent",
  "config": {
    "methods": ["read", "write"],
    "tags": ["trades", "market_data", "blockchain_wallets"]
  },
  "expires_at": "2026-12-31T23:59:59.000Z",
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f67890abcdef"
}

Connecting the Depasify MCP Server to Claude

Once you have the Truto MCP URL, connecting it to Claude requires zero custom code. The server is entirely self-contained. The token encoded in the URL tells Truto exactly which Depasify account to query and which tools to expose.

Method 1: Via the Claude UI

For enterprise users on Claude Team or Enterprise plans, or for users adding standard Custom Connectors:

1. Open Claude and navigate to Settings -> Integrations.
2. Click Add MCP Server or Add custom connector.
3. Provide a name (e.g., "Depasify Operations").
4. Paste the Truto MCP server URL you generated earlier.
5. Click Add.

Claude will perform a handshake (via the initialize JSON-RPC method), discover all available Depasify tools, and immediately make them available in your chat interface.

Method 2: Via the Configuration File

If you are using Claude Desktop for local development or testing, you can add the server by modifying the claude_desktop_config.json file. Because Truto MCP servers operate over standard HTTPS rather than requiring local execution, you will use the official Server-Sent Events (SSE) transport adapter.

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

Restart Claude Desktop. The application will connect to the Truto edge router, validate the token, and pull down the generated tool definitions.

Depasify Hero Tools for Claude

Truto automatically generates descriptive snake_case tool names and highly structured JSON schemas based on Depasify's API documentation. Here are the core tools your AI agent needs to automate financial operations.

list_all_depasify_ledgers

This tool retrieves the transaction history for a specific account. Because financial ledgers can contain thousands of entries, this tool supports pagination. Truto normalizes Depasify's cursor system into a standard limit and next_cursor schema, explicitly instructing Claude to pass cursor values back unchanged to prevent hallucinated offsets.

"Audit the ledger entries for account ID acc_98765. Find all deposits made in the last 7 days and sum the total USDT received."

create_a_depasify_blockchain_payment

Initiates a crypto withdrawal or transfer from a specific blockchain wallet. The agent must specify the wallet ID, the amount, and the currency. If the account enforces a four-eyes policy, this tool returns a status of pending_approval rather than immediately executing the transfer.

"Initiate a blockchain payment of 500 USDC from wallet ID wal_345 to the whitelisted vendor payout address."

depasify_blockchain_payments_approve

Executes the secondary approval step for pending blockchain transfers. This is critical for automated workflows where one agent drafts the payment and a separate agent (with different credentials) reviews the risk metrics before calling this tool to authorize it.

"Review pending blockchain payment ID pay_123. Ensure the destination address matches our verified vendor list, and if so, approve the payment."

create_a_depasify_trade

Executes a market order trade between fiat and crypto pairs. The agent provides the pair (e.g., EUR/BTC), the volume, and the trade type (buy or sell).

"Check the current market price for EUR/USDC. If the rate is favorable, execute a market buy order for 10,000 USDC on account acc_98765."

depasify_kyb_upload_file

Handles the complex requirement of attaching business documents to a KYB application. The tool requires the target application UUID and the specific attribute (e.g., incorporation_certificate) the document fulfills.

"Take the base64 encoded certificate of incorporation I provided, and upload it to the KYB application ID kyb_888 under the 'company_registry' attribute."

depasify_accounts_get_balance

Retrieves the real-time balance for an account, breaking down funds by currency, showing available balances, and highlighting funds pending settlement.

"Pull the current balance for account acc_98765. Tell me exactly how much EUR is available to trade versus how much is currently locked in pending settlements."

For the complete inventory of available Depasify tools and their exact JSON schema definitions, visit the Depasify integration page.

Workflows in Action

Exposing individual endpoints to an LLM is only the first step. The true power of an MCP server lies in Claude's ability to chain these tools together to orchestrate complex, multi-step financial workflows.

Scenario 1: Automated B2B Crypto Payout Orchestration

Enterprise crypto payouts often require strict oversight. An AI agent can prepare the transaction, verify the parameters, and stage it for human (or secondary agent) approval.

"We need to pay out our monthly affiliate commissions. Check our USDC balance. If we have at least 50,000 USDC available, initiate a blockchain payment of 12,500 USDC from our main operations wallet. Once initiated, confirm the pending payment ID so the finance director can approve it."

Tool Execution Sequence:

1. depasify_accounts_get_balance - Claude checks the account balance to ensure sufficient liquidity exists in the specified asset.
2. list_all_depasify_blockchain_wallets - Claude queries the account to identify the correct source wallet for the operation.
3. create_a_depasify_blockchain_payment - Claude initiates the transfer. Depasify captures the request and returns a pending_approval state due to the account's four-eyes policy.
4. Claude reads the API response and formulates a human-readable summary, handing the payment_id back to the user for the final authorization step.

sequenceDiagram
    participant User
    participant Claude as Claude Desktop
    participant MCP as Truto MCP Server
    participant DepasifyAPI as Depasify API

    User->>Claude: "Initiate affiliate payout..."
    Claude->>MCP: Call depasify_accounts_get_balance
    MCP->>DepasifyAPI: GET /accounts/{id}/balance
    DepasifyAPI-->>MCP: { "USDC": { "available": 85000 } }
    MCP-->>Claude: JSON Schema Response
    Claude->>MCP: Call create_a_depasify_blockchain_payment
    MCP->>DepasifyAPI: POST /blockchain-payments
    DepasifyAPI-->>MCP: { "id": "pay_999", "status": "pending_approval" }
    MCP-->>Claude: JSON Schema Response
    Claude-->>User: "Payment drafted. Pending ID: pay_999."

Scenario 2: Smart Trade Execution and Reconciliation

Treasury management requires reacting to market conditions and immediately logging the results for accounting.

"Check the market price for EUR to BTC. Execute a trade to convert 5,000 EUR into BTC. Once the trade settles, pull the resulting ledger entry and generate a CSV report for the accounting team."

Tool Execution Sequence:

1. depasify_market_data_get_price - Claude queries the real-time pricing endpoint for the EUR/BTC pair.
2. create_a_depasify_trade - Claude submits a market buy order for the specified volume.
3. list_all_depasify_ledgers - Claude filters the ledger entries by the exact timestamp and trade ID to verify the execution and capture the fee breakdown.
4. depasify_ledgers_get_csv_report - Claude requests a binary CSV download link containing the reconciled data, which it presents to the user.

Security and Access Control

Giving an LLM access to a financial platform like Depasify requires strict boundaries. Truto provides multiple layers of security at the MCP token level to ensure your agents operate safely.

• Method Filtering: You can enforce immutability by setting methods: ["read"] during server creation. This ensures Claude can query balances and ledgers, but cannot execute trades or initiate transfers.
• Tag Filtering: Restrict the agent's domain context. Passing tags: ["kyc"] ensures the agent only has access to identification and document tools, completely isolating it from the trading and treasury endpoints.
• Two-Layer Authentication: By setting require_api_token_auth: true, possession of the MCP URL is no longer sufficient. The MCP client must also pass a valid Truto API token in the Authorization header, ensuring only authorized team members can utilize the server.
• Automatic Expiration: For contractor access or temporary auditing workflows, set an expires_at timestamp. Truto schedules a durable cleanup task that automatically invalidates the token and destroys the edge storage records at the exact second specified.

Moving Forward

Connecting Depasify to Claude transforms static API endpoints into intelligent, agentic workflows. By leveraging a managed MCP infrastructure layer, you bypass the friction of writing pagination handlers, parsing multi-part schemas, and managing integration lifecycle updates.

Instead of dedicating engineering cycles to maintaining point-to-point connector code, your team can focus on orchestrating complex financial logic, automating compliance pipelines, and scaling your trading infrastructure.