Connect Adyen to ChatGPT: Manage Payments, Accounts, and Terminals

If you need to connect Adyen to ChatGPT to automate payment links, manage terminal fleet orders, or orchestrate merchant accounts, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between ChatGPT's tool-calling capabilities and Adyen's highly fragmented REST API surfaces. You can either engineer and host this 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 Adyen to Claude or explore our broader architectural overview on connecting Adyen to AI Agents.

Giving a Large Language Model (LLM) read and write access to enterprise fintech platforms like Adyen is an architectural challenge. You have to handle complex nested payloads, map distinct API environments (Checkout, Management, Balance Platform) into flat JSON-RPC tools, and enforce strict boundary controls so an AI agent does not accidentally refund the wrong transaction. Every time Adyen deprecates an endpoint or changes a schema, your custom MCP server must be updated and redeployed.

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

The Engineering Reality of the Adyen 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, implementing it against Adyen's API is exceptionally painful due to its specific architectural choices.

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

Fragmented API Surfaces and Credential Scopes

Adyen does not have a single monolithic API. It is split across the Checkout API, Management API, Transfers API, and Balance Platform API. Worse, credentials are scoped at different hierarchical levels - Company, Merchant, and Store. If an LLM needs to order a physical payment terminal, it must use the Management API with a Merchant-level credential. If it needs to initiate a payout, it uses the Transfers API. A custom MCP server must map these distinct environments into a single coherent toolset for the LLM, managing multiple API keys and endpoints simultaneously.

Asynchronous State and Webhook Dependency

When an LLM agent executes a write operation in Adyen - such as refunding a payment or cancelling an authorization - Adyen rarely returns the final state synchronously. Instead, it returns an HTTP 202 Accepted. The actual outcome (e.g., AUTHORISATION_ADJUSTMENT, REFUND_FAILED) is delivered asynchronously via a webhook. Your MCP server must architect a way for the LLM to either poll for state changes or register webhook listeners to confirm if the tool call actually succeeded.

Complex Nested Schemas and Flat LLM Namespaces

When an MCP client calls a tool, the LLM passes all arguments as a single, flat JSON object. However, Adyen's API payloads are deeply nested (e.g., split configuration logic, shopping cart line items, tax contexts). A custom MCP server must write heavy translation layers to map the flat LLM arguments back into Adyen's required nested body structures.

Truto handles this automatically. The MCP router derives schemas directly from Adyen's documentation, taking the flat input namespace from ChatGPT and automatically splitting it into the correct query parameters and nested body payloads before executing the proxy API call.

Step 1: Create the Adyen MCP Server

Before ChatGPT can call Adyen tools, you need an MCP server endpoint. Truto scopes every MCP server to a specific integrated account, meaning the authentication (OAuth or API keys) is handled entirely server-side.

You can generate this server via the Truto dashboard or programmatically via the Truto API.

Method A: Via the Truto UI

1. Log into your Truto dashboard and navigate to Integrated Accounts.
2. Select your connected Adyen account.
3. Click the MCP Servers tab.
4. Click Create MCP Server.
5. Select your desired configuration (e.g., limit to read-only methods or specific tags like "payments" and "terminals").
6. Copy the generated MCP server URL (it will look like https://api.truto.one/mcp/<token>). Treat this URL as a secure credential.

Method B: Via the Truto API

If you are provisioning environments programmatically, you can create the MCP server via a single POST request. This validates that the Adyen integration has tools available, generates a secure token stored in KV, and returns a ready-to-use URL.

Request:

curl -X POST https://api.truto.one/integrated-account/<integrated_account_id>/mcp \
  -H "Authorization: Bearer <your_truto_api_token>" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Adyen MCP for ChatGPT",
    "config": {
      "methods": ["read", "write"],
      "tags": ["payments", "terminals", "disputes"]
    }
  }'

Response:

{
  "id": "abc-123",
  "name": "Adyen MCP for ChatGPT",
  "config": {
    "methods": ["read", "write"],
    "tags": ["payments", "terminals", "disputes"]
  },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}

Step 2: Connect the MCP Server to ChatGPT

Once you have your Truto MCP URL, you can plug it into ChatGPT.

Method A: Via the ChatGPT UI

For users on ChatGPT Pro, Plus, Business, Enterprise, or Education tiers, you can add the URL directly to your workspace:

1. In ChatGPT, go to Settings -> Apps -> Advanced settings.
2. Ensure Developer mode is enabled.
3. Under the MCP servers or Custom connectors section, click Add new server.
4. Name: "Adyen Operations"
5. Server URL: Paste the Truto MCP URL (https://api.truto.one/mcp/...).
6. Click Save. ChatGPT will immediately perform an initialization handshake, discover the Adyen tools, and make them available in your chat interface.

Method B: Via Manual Config (Server-Sent Events Wrapper)

If you are using custom AI agents or testing locally using tools that expect standard stdio/SSE configs, you can wrap the Truto URL using the official MCP SSE server package. Create a configuration file (like chatgpt_mcp_config.json):

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

This command proxies the JSON-RPC traffic over Server-Sent Events, ensuring compatibility with strict MCP client implementations.

Adyen Hero Tools for AI Agents

Truto dynamically generates MCP tools based on Adyen's endpoint documentation. Here are the highest-leverage tools available for Adyen automation, bypassing generic CRUD operations for high-value financial actions.

Create a Payment Link

Tool: create_a_adyen_payment_link Generates a unique Adyen Pay By Link page where shoppers can pay. The AI agent can define the amount, currency, and reference. This is highly useful for support agents wanting ChatGPT to generate custom checkout links during chat sessions.

"Generate a payment link for 150 EUR for order reference ORD-9982. Return the URL so I can send it to the customer."

Refund a Payment

Tool: create_a_adyen_payment_refund Refunds a captured Adyen payment, either in full or partially. Because this triggers async webhooks, the AI agent can initiate the refund and log the resulting PSP reference for tracking.

"Refund 50 USD for the payment with PSP reference 88156123456789. Log the new refund PSP reference."

Raise a Dispute

Tool: create_a_adyen_dispute Initiates a formal dispute for an underlying transaction. The AI agent must supply the transaction ID and the type of dispute (e.g., fraud, not delivered).

"Raise a dispute for transaction ID TXN-5541. Mark the type as 'not_delivered' and set the disputed amount to the full transaction value."

List Terminal Fleet

Tool: list_all_adyen_terminals Retrieves the fleet of physical payment terminals assigned to a specific merchant account or store. Crucial for IT helpdesk agents diagnosing offline POS systems.

"List all payment terminals assigned to the 'Downtown-Store' merchant account and tell me which ones are currently offline."

Manage Terminal Orders

Tool: update_a_adyen_companie_terminal_order_by_id Allows the AI agent to update an existing terminal products order (while it is still in the 'Placed' status), modifying the shipping items or quantities.

"Update the terminal order ORD-776 to increase the quantity of Verifone.M400 terminals from 2 to 5."

Check Balance Accounts

Tool: list_all_adyen_balance_accounts Retrieves the balance accounts linked to an Adyen account holder, showing settled funds, reserve balances, and pending payouts across multiple currencies.

"Check the balance accounts for account holder ACC-889. What is their available fund balance in GBP?"

For the complete schema definitions and the full list of over 100+ Adyen operations, visit the Adyen integration page.

Workflows in Action

Here is how these tools look in production when orchestrated by an AI agent.

Scenario 1: Point-of-Sale Fleet Management

Retail operations teams often waste hours cross-referencing offline POS terminals with hardware orders. You can instruct ChatGPT to handle the entire audit and procurement cycle.

"Find all terminals at the downtown store, check their cloud status, and if they are offline, order 3 new Verifone.M400 models to replace them."

Execution flow:

1. list_all_adyen_terminals - ChatGPT queries the fleet filtered by the specific store reference to get terminal IDs.
2. get_single_adyen_device_status_by_id - The agent iterates through the IDs to check the active cloud connection status of each device.
3. create_a_adyen_merchant_terminal_order - Seeing offline devices, the agent constructs an order payload for the specified models and executes the purchase.

The user receives a summary confirming which terminals were offline and the tracking reference for the new hardware order.

Scenario 2: Support Agent Refund & Dispute Handling

Customer support agents handling complex billing scenarios need to process refunds while actively checking for chargebacks.

"Refund 50 USD for payment PSP reference XYZ, then check if there are any active disputes for that transaction and attach the customer's PDF receipt to it."

Execution flow:

sequenceDiagram
    participant User as Support Agent
    participant Agent as ChatGPT
    participant MCP as Truto MCP Server
    participant Upstream as Adyen API

    User->>Agent: "Refund 50 USD for XYZ, check disputes, attach receipt."
    Agent->>MCP: Call tool create_a_adyen_payment_refund (Amount: 50)
    MCP->>Upstream: POST /payments/XYZ/refunds
    Upstream-->>MCP: 202 Accepted (Refund PSP)
    MCP-->>Agent: Result: Refund Initiated
    
    Agent->>MCP: Call tool list_all_adyen_disputes (Filter: XYZ)
    MCP->>Upstream: GET /disputes?transactionId=XYZ
    Upstream-->>MCP: 200 OK (Dispute ID: 998)
    MCP-->>Agent: Result: Dispute 998 Found
    
    Agent->>MCP: Call tool adyen_disputes_attach_attachment (ID: 998)
    MCP->>Upstream: POST /disputes/998/attachments
    Upstream-->>MCP: 201 Created
    MCP-->>Agent: Result: Attachment Uploaded
    Agent-->>User: "Refund initiated. Attached receipt to active dispute #998."

The LLM handles the multi-step financial logic seamlessly, turning a 10-minute manual console task into a single sentence.

Scenario 3: Automated Treasury Transfers

Finance teams can use AI to manage liquidity between platforms without logging into the Adyen Customer Area.

"Check the balances for account holder DEF, and if the main balance account is over 10,000 EUR, initiate a transfer of 2,000 EUR to counterparty GHI."

Execution flow:

1. list_all_adyen_balance_accounts - ChatGPT fetches the current settled funds for the specified account holder.
2. LLM evaluates the payload to confirm the EUR balance exceeds the 10,000 threshold.
3. create_a_adyen_transfer - ChatGPT executes the transfer payload, moving funds to the designated counterparty.

The agent confirms the transfer ID and the remaining balance.

Security and Access Control

Giving AI agents write access to payment infrastructure requires strict guardrails. Truto provides infrastructure-level controls that prevent the LLM from executing unauthorized financial operations:

• Method Filtering: By passing "methods": ["read"] during server creation, you can strictly limit the MCP server to GET operations. The LLM will only see tools like list_all_adyen_terminals and will be physically blocked from seeing or calling create_a_adyen_payment_refund.
• Tag Filtering: Restrict access by business domain. Using "tags": ["terminals"] ensures the server only exposes POS hardware operations, keeping core payments completely isolated.
• Additional API Authentication: Setting require_api_token_auth: true forces the MCP client to pass a valid Truto user session token in the header. The URL alone is no longer enough to invoke tools.
• Ephemeral Servers: By setting expires_at to a future ISO datetime, the MCP server will automatically self-destruct. This is perfect for giving an AI agent temporary access to Adyen during a specific incident response window.

Factual note on rate limits: Truto does not retry, throttle, or apply backoff on rate limit errors. When the Adyen API returns 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. The AI agent or calling framework is strictly responsible for handling retry and exponential backoff logic.

Scaling Agentic Finance Workflows

Connecting Adyen to ChatGPT is not about basic API wrappers - it is about giving AI models context-aware execution capabilities over global payment infrastructure.

Instead of wasting engineering cycles reading Adyen API reference docs, dealing with nested split-payment schemas, and maintaining custom JSON-RPC routers, you can let Truto generate production-ready MCP tools dynamically.

Get your AI agents transacting today, securely and reliably.