4,500+ servers built on MCP Fusion
Vinkius

Nuvei MCP. Manage the entire payments lifecycle from chat.

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
See Vinkius in Action

Works with every AI agent you already use

…and any MCP-compatible client

Nuvei MCP on Cursor AI Code Editor MCP Client Nuvei MCP on Claude Desktop App MCP Integration Nuvei MCP on OpenAI Agents SDK MCP Compatible Nuvei MCP on Visual Studio Code MCP Extension Client Nuvei MCP on GitHub Copilot AI Agent MCP Integration Nuvei MCP on Google Gemini AI MCP Integration Nuvei MCP on Lovable AI Development MCP Client Nuvei MCP on Mistral AI Agents MCP Compatible Nuvei MCP on Amazon AWS Bedrock MCP Support

Just plug in your AI agents and start using Vinkius.

Nuvei connects your AI agent directly to its global payments platform. Use it to track live transactions, securely tokenize card details into a vault, and process charges—all from natural conversation.

It lets you manage everything from initial authorization requests via `create_payment` to checking final settlement status with `get_payment`. Stop logging into the dashboard; handle your money moves in chat.

What your AI agents can do

Capture payment

Finalizes a previously authorized payment charge. If you leave out an amount, it captures the full total.

Create card token

Takes raw card details and converts them into a secure, vaulted token for future use.

Create payment

Starts the process of a new payment charge by initiating an authorization request with Nuvei.

+ 7 more capabilities included
Process new charges

Initiates a live payment authorization or charge using create_payment for immediate sales orders.

Securely vault card details

Converts raw credit card numbers into non-sensitive tokens using create_card_token.

Check payment status

Retrieves the current, confirmed status of a transaction using a specific Payment ID via get_payment.

Audit history

Lists and enumerates historical payment records across your entire merchant account using get_transactions.

Manage stored tokens

Retrieves details for vaulted card or payment tokens using get_token, or modifies them with update_token.

Reverse funds

Handles refunds via refund_payment (supports partial amounts) or cancels pending authorizations using void_payment.

Supported MCP Clients

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
+ other MCP clients
Free for Subscribers

Waiting for input…

AI Agent

Nuvei MCP Server: 10 Tools for Payment Management

Use these tools to manage the entire payment lifecycle. You can authorize charges, vault card details, audit history, and process refunds—all through your AI agent.

capture019d75e0

capture payment

Finalizes a previously authorized payment charge. If you leave out an amount, it captures the full total.

create019d75e0

create card token

Takes raw card details and converts them into a secure, vaulted token for future use.

create019d75e0

create payment

Starts the process of a new payment charge by initiating an authorization request with Nuvei.

delete019d75e0

delete token

Permanently removes a stored, vaulted payment token, stopping all future charges linked to it.

get019d75e0

get payment

Retrieves the current status of any specific payment using its unique Nuvei ID.

get019d75e0

get token

Looks up and displays all details associated with a stored, vaulted card or payment token.

get019d75e0

get transactions

Lists and counts multiple historical transaction records across the entire account for auditing purposes.

refund019d75e0

refund payment

Issues a refund against a fully captured payment. You can specify amounts to issue partial refunds.

update019d75e0

update token

Changes specific details on an existing token, like updating the expiration date, without needing raw card data.

void019d75e0

void payment

Cancels a payment that is still pending authorization, stopping it before any charge occurs.

Choose How to Get Started

Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.

Build Your Own

Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.

  • Import from OpenAPI, Swagger, or YAML specs
  • Create Agent Skills with progressive disclosure
  • Deploy to edge with MCPFusion framework
  • Built in DLP, auth, and compliance on every call
  • Real time usage dashboard and cost metering
  • Publish to catalog or keep private
Start building

Make Your AI Do More

Start with Nuvei, then connect any of our 4,700+ other servers whenever your AI needs more. One click, no limits.

  • Use this MCP plus 4,700+ others, all in one place
  • Add new capabilities to your AI anytime you want
  • Every connection is secured and compliant automatically
  • Track usage and costs across all your servers
  • Works with Claude, ChatGPT, Cursor, and more
  • New servers added to the catalog every week

What you can do with this MCP connector

Nuvei connects your AI agent directly to its global payments platform, letting you manage money moves without ever logging into a dashboard. You'll use this server to handle everything from initial authorization requests to final transaction reconciliation—all through natural conversation.

Processing Live Charges and Reversing Funds
You initiate new sales orders by calling create_payment, which starts the payment process with an authorization request. Once you confirm the sale, you finalize the charge using capture_payment; if you forget the specific amount, it automatically captures the full total from the authorized amount. If a transaction is pending and needs to be canceled before any money moves, use void_payment.

For fully captured payments that need adjustment, call refund_payment, which handles issuing refunds; you can specify amounts, so partial refunds are no problem.

Managing Card Data: Tokenization and Vaulting
You never gotta handle raw card data again. You convert sensitive credit card numbers into secure, non-sensitive tokens using create_card_token. This action sends the payment details straight into Nuvei’s vault for future use. To access any stored payment method or vaulted token's specific details, you run get_token.

When a customer needs to update their information—say, the expiration date on a card—you modify it using update_token, and you don't need to collect raw card data for that. If you decide a stored payment method is no longer valid or necessary, delete_token permanently removes it from the vault, stopping all future charges linked to that token.

Checking Status and Auditing History
Need to know if a charge actually went through? Use get_payment by supplying a specific Nuvei Payment ID; this tool retrieves the current, confirmed status of any transaction. For looking at everything you’ve done, run get_transactions. This lists and counts historical payment records across your entire merchant account, making auditing simple.

The Workflow in Practice
Your AI client acts as the intermediary. When a user asks to process a charge or check history, your agent executes the appropriate tool call (like create_payment or get_transactions), sends the necessary data to Nuvei, and reports the resulting status right back to you. It handles authorization requests, token conversions, fund reversals, and audit summaries so you don't have to switch screens.

How Nuvei MCP Works

  1. 1 Subscribe to the Nuvei server and input your API keys and merchant details into your AI client.
  2. 2 Prompt your agent with a payment goal (e.g., 'Charge $50 to card ending in 4242').
  3. 3 Your agent runs create_payment or create_card_token, sends the data, and returns the transaction confirmation ID.

The bottom line is: you treat complex financial processes like simple conversation prompts. The server handles the API calls.

Who Is Nuvei MCP For?

This is for anyone whose job involves money flow but doesn't want to jump between dashboards and APIs. It targets developers building e-commerce systems, finance analysts needing instant reconciliation data, and customer support agents who need to resolve payment disputes quickly.

E-commerce Engineer

Uses the agent to securely implement checkout flows by calling create_card_token before running live charges with create_payment.

FinOps Analyst

Runs batch queries using get_transactions or checks failed payments via get_payment to reconcile daily accounting without manual exports.

Customer Support Manager

Locates a customer's specific transaction ID and verifies its status instantly by running get_payment within the CRM workflow.

What Changes When You Connect

  • Audit failed charges instantly. Use get_transactions to list and summarize batches of historical records, letting you quickly see why a payment flow tripped up without exporting CSVs.
  • Handle customer card data safely. Running create_card_token means you never touch raw credit card numbers again; the token is all your app needs for future purchases.
  • Verify payments on demand. If a user reports an issue, run get_payment with their ID to get the precise status (e.g., Declined, Approved) and troubleshooting details.
  • Control funds precisely. You can use void_payment to cancel pending charges before they process, or execute partial returns using refund_payment after a sale.
  • Eliminate redundant steps. Instead of writing complex multi-step code for checkout, just call create_card_token followed by create_payment. The agent manages the sequence.

Real-World Use Cases

01

Customer Support: Verifying a charge

A user calls in saying their payment failed. Instead of asking them to email screenshots, your agent asks for the transaction ID and runs get_payment. The response immediately confirms if the failure was due to 'Insufficient Funds' or an 'Expired Card,' letting you give them a real answer right away.

02

E-commerce Checkout: New customer purchase

A new shopper hits checkout. The agent first calls create_card_token to securely save their card details, then immediately uses those stored tokens with create_payment to finalize the sale without requiring them to re-enter anything.

03

Finance: Daily Reconciliation

The accounting team needs a summary of yesterday's payments. They prompt the agent, which runs get_transactions. The result is an immediate table showing 9 approved charges and 1 refund in pending status—no manual dashboard clicking required.

04

Developer Testing: Simulating refunds

A product engineer needs to test a partial return flow. They use get_token first, then run refund_payment, specifying the exact dollar amount they want to reverse, testing the full loop without touching production code.

The Tradeoffs

Capturing before authorizing

A developer writes a function that calls capture_payment immediately upon receipt of card data. This fails because you must first run an authorization request to reserve the funds.

You gotta separate the steps. First, use create_payment to initiate the authorization. Only call capture_payment later when both sides confirm the sale.

Handling card data in code

Storing raw credit card numbers in environment variables or logs for processing fallback scenarios, which is a massive PCI compliance risk.

Always tokenize. Run create_card_token first. Then, only use the resulting token when running any payment tools like get_token or create_payment. Never store raw data.

Assuming immediate finalization

Calling a charge tool and assuming the money is instantly settled in the bank account, which isn't true for most payment gateways.

Always confirm status. After running create_payment, follow up by calling get_payment later to verify if the async settlement cleared successfully.

When It Fits, When It Doesn't

Use this server if your problem involves tracking, managing, or executing payments against a real-world payment gateway. If you need to secure card data, start with create_card_token. If you just need to read historical reports, stick to get_transactions. Don't use it if you are only building local mockups; the server performs live network requests. And don't rely on it for fraud detection—it handles the transaction mechanics, but your business logic still needs to manage risk (e.g., checking IP location or requiring 3D secure confirmation before running create_payment).

Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Nuvei. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.

VINKIUS INFRASTRUCTURE

Cloud Hosted

Managed infra

V8 Isolated

Sandboxed per request

Zero-Trust Proxy

No stored credentials

DLP Enforced

Policy on every call

GDPR Compliant

EU data residency

Token Compression

~60% cost reduction

How we secure it →

Works with Claude, ChatGPT, Cursor, and more

The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.

This server provides 10 capabilities that interface natively with Claude, ChatGPT, Cursor, and any MCP client. No middleware. No custom integration required.

Available Capabilities

capture_payment create_card_token create_payment delete_token get_payment get_token get_transactions refund_payment update_token void_payment

Manually tracking payment status is a pain.

Today, if you need to know why a transaction failed, your workflow probably involves checking the dashboard, copying an ID, logging into the secondary system, and cross-referencing logs. It's slow, it's clunky, and frankly, it takes too many clicks.

With Nuvei MCP, that whole process shrinks to one line of code. You ask your agent for the status using `get_payment`, and you get a clean answer right back—the final settlement state, not just an error message.

Nuvei MCP Server: Run full payment cycles from chat.

Forget the three-step process of authorizing funds, getting the card on file, and then finally capturing the amount. The agent handles that entire sequence for you through simple calls like `create_card_token` followed by a single charge action.

It's done. You go from zero to fully processed payment flow in two prompts—no middleware, no manual API sequencing needed.

Common Questions About Nuvei MCP

How do I check the status of a transaction using Nuvei MCP Server? +

You use get_payment. You just need to provide the unique Payment ID. The tool returns the current, authoritative status from Nuvei's system.

Should I call create_card_token before creating a payment? +

Yes, you should. Use create_card_token first to get a secure token for the card. Then, use that token when running create_payment. This keeps your raw data out of the main workflow.

What's the difference between capture_payment and create_payment? +

Think of it this way: create_payment initiates a pre-authorization (reserving funds). capture_payment finalizes that reservation, actually taking the money.

Can I refund multiple payments at once using Nuvei MCP Server? +

No. The refund_payment tool handles one payment at a time. You'll need to run it iteratively for each amount you want to return.

When should I use the `void_payment` tool instead of canceling a charge? +

The void_payment command cancels payments that are still pending authorization. You can only void transactions that haven't been captured yet, meaning it prevents any future charges from going through.

What specific fields can be modified using the `update_token` tool? +

The update_token function allows you to mutate specific attributes within a vaulted token. This is useful for changing details, such as updating an expiration date string, without needing access to raw card data again.

What happens when I use the `delete_token` tool? +

Calling delete_token permanently removes a vaulted payment method. This action immediately stops all future recurring charges or one-click purchases linked to that specific token, making it irreversible.

Are there usage restrictions when running the `create_payment` tool? +

Yes, Nuvei enforces standard API rate limits. You must check their official documentation for current quotas and throttling details to ensure your agent remains stable during high-volume processing.

How can I securely pass card inputs if the chat format is plain text? +

The integration routes direct requests to Nuvei's sandbox or live vault using the create_card_token feature natively. Since the AI environment is localized and isolated by default, inputs made within Claude or Cursor are ephemeral and pass straight into Nuvei via the secure connection layer without persisting in logs.

Can I query why a specific transaction was declined? +

Yes. Ask the agent to use get_payment with your transaction ID. The AI will parse the complex payload returned by Nuvei and summarize the error message (e.g., Insufficient Funds, Do Not Honor) directly in human language.

Is it possible to track batch settlements? +

Use the get_transactions capability. Your prompt can specify that you want to list out the last 20 payments, and the AI will structure them neatly as a tabular view in your chat interface.

More in this category

You might also like

Built & Managed by Vinkius 30s setup 10 tools

We've already built the connector for Nuvei. Just plug in your AI agents and start using Vinkius.

No hosting. No infrastructure. No complex setup.
All 10 tools are live and waiting. You're up and running in seconds.

Claude Claude
ChatGPT ChatGPT
Cursor Cursor
Gemini Gemini
Windsurf Windsurf
VS Code VS Code
JetBrains JetBrains
Vercel Vercel
+ other MCP clients

Vinkius gives your AI agents access to the full catalog of app connectors, all fully managed, secure, and enterprise-ready. One subscription, every tool you need.

Zero hosting required Full MCP catalog included Enterprise-grade security Auto-updated by Vinkius

Built, hosted, and secured by Vinkius. You just connect and go.