Connect Airwallex to ChatGPT: Automate Global Payouts & Card Issuing

If you need to connect Airwallex to ChatGPT to automate cross-border payouts, execute real-time FX conversions, or orchestrate corporate card issuing, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between an LLM's JSON-RPC tool calls and the highly regulated, idempotency-strict Airwallex REST API. You can either spend weeks building and auditing this integration infrastructure yourself, or use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL.

If your team uses Claude, check out our guide on connecting Airwallex to Claude or explore our broader architectural overview on connecting Airwallex to AI Agents.

Giving a Large Language Model (LLM) read and write access to a financial platform like Airwallex is a massive engineering challenge. You are dealing with real money movement, strict KYC/KYB data models, and complex, asynchronous transaction lifecycles. Every time a developer adds a new supported currency or modifies a payout route, your custom server code must be updated, redeployed, and rigorously tested to prevent double-spending or failed authorizations.

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

The Engineering Reality of the Airwallex API

A custom MCP server is essentially a self-hosted API proxy layer. While the open MCP standard provides a predictable way for models to discover and invoke tools, implementing it against Airwallex's API is exceptionally painful.

If you decide to build a custom MCP server for Airwallex in-house, you own the entire API lifecycle. Here are the specific integration challenges that break standard CRUD assumptions when working with Airwallex:

Mandatory Idempotency Keys and Flat Namespaces

Financial APIs cannot tolerate duplicate requests. Almost every mutation in the Airwallex API (e.g., creating a transfer, issuing a card, executing a conversion) strictly requires a unique request_id header or body field for idempotency. When passing instructions from an LLM, the model must reliably generate and supply this ID. Furthermore, LLMs struggle with deeply nested JSON schemas. Truto's MCP architecture solves this by parsing Airwallex's OpenAPI/Swagger documentation and flattening the query and body schemas into a single, predictable input namespace for the LLM. The LLM passes a flat object, and Truto routes the arguments to the correct HTTP locations (path, query, body, or headers).

Handling 429 Rate Limits and Backoff Protocols

When your AI agent attempts to process a batch of 50 FX conversions or paginate through thousands of card transactions, it will inevitably hit Airwallex's API rate limits. Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream Airwallex API returns an HTTP 429 (Too Many Requests), Truto instantly passes that exact error back to the caller. However, Truto normalizes the upstream rate limit information into standardized HTTP headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF specification. It is entirely the responsibility of the calling agent (or framework like LangChain/Auto-GPT) to read these normalized headers and apply the appropriate retry and exponential backoff logic.

Asynchronous Lifecycles and Expirations

Airwallex workflows are rarely synchronous one-offs. For example, obtaining an FX conversion quote (validity_period) means the quote is only actionable for a specific window. Batch transfers transition through states like DRAFTING, IN_APPROVAL, and SCHEDULED. Your agent needs tools that accurately reflect these strict state machines—if an LLM tries to execute a conversion on an expired quote, or delete a batch transfer that has already moved past DRAFTING, the Airwallex API will reject it. Truto curates the MCP tool schemas directly from Airwallex's documentation, ensuring the LLM understands exactly which status transitions are currently valid.

Airwallex to ChatGPT Quickstart Guide

If you just want the fastest path from a fresh Truto account to ChatGPT successfully invoking the Airwallex API, follow these steps.

What you need:

• A Truto account with API access.
• An Airwallex account with API credentials (Client ID and API Key).
• A ChatGPT Pro, Plus, Business, Enterprise, or Education seat with Developer mode available, OR the Claude desktop app.

Step 1: Connect Airwallex as an Integrated Account

In the Truto dashboard, navigate to Integrated Accounts -> New Integrated Account, select Airwallex, and input your API credentials. Truto securely vaults these credentials and handles the token exchange (/api/v1/authentication/login) under the hood, ensuring your agent never sees an expired access token.

Copy your integrated_account_id. You can find this in the UI or list it via the API:

curl -X GET https://api.truto.one/integrated-account \
  -H "Authorization: Bearer $TRUTO_API_TOKEN"

Step 2: Generate an Airwallex MCP Server

You can create an MCP server scoped to your Airwallex connection either through the Truto UI or via the API.

Method A: Via the Truto UI

1. Navigate to the integrated account page for your Airwallex connection.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration (e.g., name it "Airwallex FinOps", set allowed methods to read and write, and apply tags like transfers and issuing).
5. Copy the generated MCP server URL (https://api.truto.one/mcp/<token>).

Method B: Via the API Make a single POST call to scope an MCP endpoint to your account. Filtering by methods and tags acts as a security boundary, constraining exactly what the LLM is allowed to touch.

curl -X POST https://api.truto.one/integrated-account/$INTEGRATED_ACCOUNT_ID/mcp \
  -H "Authorization: Bearer $TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Airwallex for ChatGPT",
    "config": {
      "methods": ["read", "write", "custom"],
      "tags": ["transfers", "conversions", "issuing"]
    }
  }'

The response contains a url field. This URL carries the routing instructions and authentication token for your specific Airwallex environment. Treat this URL like a secret.

Step 3: Connect the MCP Server to Your Agent Client

Now, feed this URL to your LLM client so it can dynamically discover the Airwallex tools via the JSON-RPC protocol.

Method A: Via the ChatGPT UI

1. Open ChatGPT and navigate to Settings -> Apps -> Advanced settings.
2. Enable the Developer mode toggle (MCP support is currently behind this flag).
3. Under MCP servers / Custom connectors, click to add a new server.
4. Name: "Airwallex (Truto)"
5. Server URL: Paste the Truto MCP URL you copied in Step 2.
6. Click Save. ChatGPT will perform the MCP handshake, list the available tools, and make them available in your chat interface.

Method B: Via manual config file (for Claude Desktop or custom agents) If you are using Claude Desktop or running a local agent framework, configure your claude_desktop_config.json (or equivalent MCP configuration) to use Truto's remote SSE transport:

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

Airwallex Hero Tools for AI Agents

Once connected, Truto exposes Airwallex's API resources as curated, LLM-ready tools. The documentation schemas act as a strict quality gate—only endpoints with clear, machine-readable descriptions become tools.

Here are the highest-leverage Airwallex tools your agent can now call:

1. list_all_airwallex_balances

Retrieves current balances, available amounts, and pending amounts across every currency in your Airwallex wallet.

• Context: Before executing payouts or FX conversions, the agent must verify sufficient funds in the source currency to avoid "Insufficient Funds" API errors.

"Check our current wallet balances. Do we have at least 15,000 EUR available, or do we need to execute a USD to EUR conversion first?"

2. create_a_airwallex_conversions_create

Executes a new foreign exchange (FX) conversion within the Airwallex wallet, moving funds from a buy currency to a sell currency at the current client rate.

• Context: The agent must supply a unique request_id, the buy_currency, the sell_currency, and exactly one of buy_amount or sell_amount.

"Convert 5,000 USD to GBP immediately at the current market rate to fund our UK payroll batch."

3. create_a_airwallex_transfers_create

Initiates a single cross-border or local transfer to a beneficiary, with an optional underlying FX conversion if the source and transfer currencies differ.

• Context: Requires reason, reference, request_id, and transfer_currency. The agent must carefully map the beneficiary's banking details into the flat payload.

"Initiate a transfer of 1,200 SGD to our marketing contractor in Singapore. Use the reference 'Q3 Content Retainer'."

4. create_a_airwallex_issuing_cardholder

Creates a new individual or delegate cardholder profile in Airwallex Issuing. This triggers Airwallex's name and sanction screening processes.

• Context: Required before you can issue a corporate card. You must supply email, individual details (name, DOB), and type.

"Create a new issuing cardholder profile for our new hire, Sarah Jenkins (sarah@example.com), as an INDIVIDUAL."

5. create_a_airwallex_issuing_card

Provisions a new physical or virtual corporate card, attaching spend controls, delivery details, and program settings.

• Context: Requires cardholder_id, form_factor (VIRTUAL or PHYSICAL), and authorization_controls. Agents can enforce strict limits (e.g., $500/day) during creation.

"Issue a new virtual card for Sarah Jenkins. Set a daily spending limit of $500, restricted to software subscriptions, and activate it immediately."

6. create_a_airwallex_batch_transfer

Creates a new batch transfer draft for bulk payouts.

• Context: The batch begins in DRAFTING status. The agent must subsequently use create_a_airwallex_batch_transfer_add_item to attach up to 1000 line items, and then create_a_airwallex_batch_transfer_submit to execute the batch.

"Initialize a new batch transfer draft for our monthly affiliate payouts, and name the batch 'Affiliates Oct 2026'."

(Note: This is only a curated selection of high-leverage capabilities. For the complete list of available operations, schemas, and required parameters, visit the Airwallex Integration Page.)

Workflows in Action

MCP tools become truly powerful when an agent chains them together to accomplish complex, multi-step financial operations that would otherwise require manual intervention in the Airwallex dashboard.

Scenario 1: Multi-Currency Payout Orchestration

An operations manager asks ChatGPT to pay an invoice in a foreign currency, but the wallet lacks sufficient funds in that specific currency.

User: "I need to pay our design agency 4,500 EUR for the rebrand. Check if we have enough EUR. If not, convert USD to cover it, then send the transfer to beneficiary ID ben_8x9Y2Z. Use reference 'Rebrand Final'."

How the Agent Executes:

1. Calls list_all_airwallex_balances to check the EUR available_amount.
2. Notes the balance is only 500 EUR. Calculates a shortfall of 4,000 EUR.
3. Generates a random request_id and calls create_a_airwallex_conversions_create with buy_currency: "EUR", sell_currency: "USD", and buy_amount: 4000.
4. Generates a new request_id and calls create_a_airwallex_transfers_create with beneficiary_id: "ben_8x9Y2Z", transfer_currency: "EUR", amount: 4500, reason: "Payment for services", and reference: "Rebrand Final".

Result: The agent replies confirming the FX conversion rate obtained and provides the final transfer tracking ID, successfully navigating a multi-step currency shortage without human intervention.

sequenceDiagram
    participant User as User
    participant ChatGPT as ChatGPT (Client)
    participant Truto as Truto MCP Server
    participant Airwallex as Airwallex API
    
    User->>ChatGPT: "Pay agency 4,500 EUR..."
    
    ChatGPT->>Truto: call_tool("list_all_airwallex_balances")
    Truto->>Airwallex: GET /api/v1/balances
    Airwallex-->>Truto: { "available_amount": 500, "currency": "EUR" }
    Truto-->>ChatGPT: Result: 500 EUR
    
    ChatGPT->>Truto: call_tool("create_a_airwallex_conversions_create", {buy_amount: 4000...})
    Truto->>Airwallex: POST /api/v1/pa/conversions/create
    Airwallex-->>Truto: { "status": "SETTLED" }
    Truto-->>ChatGPT: Conversion successful
    
    ChatGPT->>Truto: call_tool("create_a_airwallex_transfers_create", {amount: 4500...})
    Truto->>Airwallex: POST /api/v1/transfers/create
    Airwallex-->>Truto: { "status": "SCHEDULED", "id": "txn_123" }
    Truto-->>ChatGPT: Transfer initiated
    
    ChatGPT-->>User: "Converted USD to EUR. Transfer txn_123 is scheduled."

Scenario 2: Zero-Touch Corporate Card Provisioning

An IT admin requests a new virtual card for a contractor to pay for cloud infrastructure.

User: "We just hired John Doe (john.d@contractor.com). Create a cardholder profile for him, then provision a virtual card locked to 1,000 USD per month for software expenses."

How the Agent Executes:

1. Calls create_a_airwallex_issuing_cardholder providing the individual's details and setting type to INDIVIDUAL. Extracts the resulting cardholder_id.
2. Calls create_a_airwallex_issuing_card using the cardholder_id, setting form_factor to VIRTUAL, and passing the specific authorization_controls (limit amount: 1000, interval: MONTHLY, merchant categories: Software).
3. Calls list_all_airwallex_card_details using the new card_id to retrieve the sensitive PAN, CVV, and expiry data securely.

Result: The agent provisions the user, successfully passes the screening API, configures the velocity limits, and returns the encrypted or raw card details to the authorized admin for immediate use.

Security and Access Control

Exposing financial APIs to an LLM requires strict boundary management. Truto's MCP architecture provides several layers of access control out of the box:

• Method Filtering: When generating the MCP URL, you can strictly allow only read operations. If an agent attempts to execute a create_a_airwallex_transfers_create tool on a read-only server, Truto intercepts and blocks the call.
• Tag Filtering: Restrict the server to specific functional domains. Setting tags: ["issuing"] ensures the LLM can only see and interact with card-related endpoints, hiding transfers and balances entirely.
• Conditional Authentication: Setting require_api_token_auth: true ensures that simply possessing the MCP URL is insufficient. The client must also pass a valid Truto API token in the Authorization header to invoke tools.
• Automatic Expiration: You can provision temporary access for contractors or temporary agents by setting an expires_at ISO datetime. Truto automatically destroys the token and drops access precisely at the expiration time via durable object alarms.
• Rate Limit Passthrough: As noted, Truto protects the upstream infrastructure by passing Airwallex 429s directly to your client and normalizing the IETF headers. Your agent architecture remains responsible for honoring these backoff limits.

Moving Past Integration Boilerplate

Building an AI agent that can reliably move money and provision financial infrastructure via Airwallex is no longer blocked by writing thousands of lines of schema parsing, rate-limit backoff handling, and authentication lifecycle code.

By leveraging an auto-generated MCP server, your engineering team can treat Airwallex as a dynamic set of tools, perfectly mapped to the LLM's context window.

Focus on building safer agentic workflows, better prompting architectures, and tighter approval loops. Let the infrastructure layer handle the REST API translation.