# Checkout.com MCP for AI Agents MCP

> Checkout.com MCP lets your AI client manage global payments conversations. You can track transactions, capture authorizations, and process refunds across 150+ currencies without leaving your chat window.

## Overview
- **Category:** money-moves
- **Price:** Free
- **Tags:** global-payments, transaction-processing, refunds, payment-gateway, currency-management

## Description

Managing global e-commerce payments used to mean logging into a dashboard, navigating between tabs, and manually cross-referencing transaction IDs. Now, you talk to your AI client and get the answers instantly.

This MCP lets you take full control of every aspect of your payment lifecycle in natural conversation. Need to know what happened to an authorization? Ask. Want to process a refund for a specific order ID? Tell it to do it. You can list recent payments, check detailed history via `list_checkout_payments`, or even verify webhook delivery using `list_checkout_webhooks`.

It handles the messy details too; you don't have to worry about minor unit math because we manage precise financial amounts in minor units for high-accuracy transactions. This kind of deep control over global payments is usually reserved for complex internal tooling, but connecting through the Vinkius catalog makes it accessible right from your workspace. You can even perform mutable operations like capturing or voiding funds directly, giving you complete oversight and auditability.

## Tools

### capture_checkout_payment
Finalizes an authorized payment, converting it into captured funds.

### get_checkout_account_info
Retrieves fundamental details about your Checkout.com account and user settings.

### list_payment_actions
Generates a full chronological list of every event that occurred with a specific payment ID.

### get_payment_details
Gathers all available data points for one particular transaction record.

### list_checkout_payments
Pulls a list of the most recent payments processed through your account.

### list_checkout_webhooks
Shows all webhooks currently set up, verifying system connectivity and data flow.

### refund_checkout_payment
Initiates the process of returning money to a payment that was previously captured.

### void_checkout_payment
Cancels an authorization before it has been captured or processed.

## Prompt Examples

**Prompt:** 
```
What were all the payments processed last week that are currently only 'Authorized'?
```

**Response:** 
```
**Payment Summary: Authorized Funds (Last 7 Days)**

| Order ID | Amount | Status | Date |
| :--- | :--- | :--- | :--- |
| #90210 | $54.99 | Authorized | Yesterday |
| #33876 | €12.50 | Authorized | 3 Days Ago |

*Action required: These payments need to be captured before fulfillment.*
```

**Prompt:** 
```
I need to issue a refund for payment ID 'pay_99a'. It was for $75 last month.
```

**Response:** 
```
**Refund Request Status**

✅ Refund of **$75.00** successfully submitted for `pay_99a`.

The funds are being processed and the new status will be reflected in the payment actions within minutes. Please check back later to confirm the final reversal details.
```

**Prompt:** 
```
Can you list my recent payments, but only show me those that failed or were voided?
```

**Response:** 
```
**Voided & Failed Payments Report**

Here are the three transactions matching your criteria:

*   Order #XYZ: $12.00 (Status: Voided) - *Action taken manually.*
*   Order #ABC: €5.00 (Status: Declined) - *Reason: Insufficient funds.*
*   Order #DEF: $9.99 (Status: Failed) - *Attempt reason: Invalid card number.*
```

## Capabilities

### List all recent payments
Retrieves a list of transactions that have recently been processed through Checkout.com.

### Get detailed payment history
Fetches comprehensive information for a single, specific transaction ID.

### Process refunds or void payments
Issues immediate commands to refund captured funds or cancel pending authorizations.

### List payment actions history
Shows the full timeline of events—like authorization, capture, and refund—for any given payment ID.

### Retrieve core account data
Pulls foundational details about your Checkout.com account and user settings.

### Monitor webhooks
Reviews which system hooks are configured to ensure automated integrations are running correctly.

## Use Cases

### Investigating a chargeback status
A customer service agent asks their AI client, 'What was the full history for order ABC?' The agent uses `list_payment_actions` and immediately provides the detailed timeline showing authorization, capture, and any subsequent adjustments.

### Processing a bulk refund request
The finance team needs to issue refunds for several cancelled orders. Instead of logging into the portal multiple times, they instruct their agent to `refund_checkout_payment` using the list of payment IDs provided.

### Checking API connectivity post-update
A developer needs to confirm that a new webhook listener is active. They ask the agent to `list_checkout_webhooks`, instantly validating the configuration against Checkout.com's live settings.

### Confirming payment readiness
An e-commerce manager needs to ensure an authorization can be finalized before shipping goods. They use the MCP to `get_payment_details` and confirm the status, then instruct the agent to `capture_checkout_payment`.

## Benefits

- Audit transaction history instantly: Check the full lifecycle of any payment using `list_payment_actions` without digging through multiple screens.
- Control payments conversationally: You can capture, void, or refund funds simply by asking your agent to perform the action.
- Maintain high accuracy with minor units: The MCP handles precise financial amounts in minor units, ensuring zero calculation errors for complex accounting.
- Verify integrations quickly: Use `list_checkout_webhooks` to confirm that automated data feeds are running flawlessly during development or maintenance.
- Get account health checks: Quickly retrieve core user and account information using `get_checkout_account_info`, keeping your operational context fresh.
- Stay in one place: Process payments, view details (`get_payment_details`), and list transactions all within a single chat window.

## How It Works

The bottom line is: you never have to leave your chat interface to manage payments; your AI agent handles all the API calls for you.

1. Subscribe to this MCP and provide your Checkout.com Secret Key and API Prefix.
2. Connect the MCP to any compatible AI client (like Cursor or Claude).
3. Ask your agent a question, like 'What happened to payment X?' and it executes the necessary actions using the toolset.

## Frequently Asked Questions

**How do I check the full history of a payment using Checkout.com MCP for AI Agents?**
You simply ask your agent what happened to a specific transaction ID. It retrieves all associated lifecycle actions, showing the exact dates and times when the payment was authorized, captured, or refunded.

**Can I use Checkout.com MCP for AI Agents to process refunds?**
Yes. You can instruct your agent to refund a previously captured payment. It handles the required financial logic and submits the request directly through Checkout.com's secure channels.

**Is this better than checking the Checkout.com dashboard manually?**
It’s faster and more conversational. Instead of clicking through multiple reports, you ask your agent for exactly what you need—a summary, a list, or an action—and get it immediately.

**Does Checkout.com MCP for AI Agents handle different currencies?**
Yes. It is built to manage global payments across over 150 currencies, ensuring the math and financial units are precise no matter where the transaction originated.

**If I need to void a payment, do I have to use the website?**
No. You can ask your AI agent to perform the void action directly through the MCP. It verifies the status first and then executes the cancellation command for you.

**What if my webhook setup is broken? Can Checkout.com MCP help?**
You can use the MCP to list and review your configured webhooks. This lets you quickly verify connectivity details, helping a developer pinpoint exactly where an integration failed.