Skip to main content

Nium MCP Server

Easily integrate with Nium APIs using AI coding agents and the Nium MCP Server.

The Model Context Protocol (MCP) is a standard that lets AI models interact with external tools and services.

The Nium MCP Server uses MCP to give AI assistants such as Claude, Cursor, and ChatGPT a common, secure connection to Nium. AI coding agents and LLMs can use it to understand the following in natural language:

  • Nium APIs
  • Nium documentation
  • Integration workflows

With this understanding, developers can build, test, and troubleshoot global payments integrations faster, without manually navigating documentation.

Advantages
  • Zero infrastructure overhead: Connect to the hosted Nium MCP Server with a URL and an API key. There is nothing to install, host, or maintain.
  • AI-powered automation: Run payment workflows, such as onboarding a customer or sending a payout, using natural language commands.
  • Faster development: Build and test Nium integrations faster with AI assistance grounded in the Nium API specification.
  • Sandbox operations: Run Nium API operations in your Sandbox account directly from your AI assistant.
  • Seamless integration: Works with popular AI tools, including Cursor, Claude Code, Claude Desktop, VS Code, Codex, and ChatGPT.
Features

Transform how you build and test global payments integrations with AI-powered automation:

  • Explore Nium APIs: Ask questions about Nium APIs, request fields, and call sequences without navigating the documentation.
  • Generate integration code: Produce working integration code, such as customer onboarding, beneficiary creation, payouts, and webhook handling, in the language and framework you choose.
  • Run Sandbox workflows: Create customers, beneficiaries, and payouts in Sandbox in a single conversation, and check transaction status in real time.
  • Check corridor coverage: Look up payout rails, cutoff times, limits, and mandatory beneficiary fields for a destination country and currency.
  • Troubleshoot failing requests: Compare a failing request with the API specification to find what's wrong and how to fix it.

See Use Cases for examples and prompts.

Limitations
  • Model dependency: Quality varies by model. Different AI assistants produce different results, and no model is perfect.
  • Sandbox only: The Nium MCP Server runs in Sandbox only. No production funds are moved. Email developers@nium.com to register interest in production support.
  • Hallucination reduction, not elimination: The server grounds your AI assistant in the Nium API specification, but it can't eliminate errors. Always review, validate, and test generated code and recommendations before you use them in production.
  • Things your assistant can't do (yet): Make your coffee, approve your pull request, or move production funds. It can, however, ask you nicely for any beneficiary details it's missing.
New to building with AI agents?

Learn how MCP (Model Context Protocol) helps tools like Claude, ChatGPT, Cursor, and VS Code work with APIs and documentation.

Before you begin​

You need a Nium Sandbox account and an API key.

  1. Sign in to Nium Portal. No account? Sign up free — Sandbox access is instant.
  2. Go to Settings → API Keys and copy your API Key.
Claude Desktop walkthrough

Using Claude Desktop? See Tutorial: Connect Claude Desktop to the Nium MCP Server for a complete step-by-step guide with screenshots.

Install​

Cursor​

Add to Cursor

After clicking, replace YOUR_NIUM_API_KEY in the x-api-key header with your API key.

Or configure manually — add the following to ~/.cursor/mcp.json (global) or .cursor/mcp.json (project root):

{
  "mcpServers": {
    "Nium_Sandbox": {
      "url": "https://mcp-sandbox.nium.com/mcp",
      "headers": {
        "x-api-key": "${env:NIUM_API_KEY}"
      },
      "env": {
        "NIUM_API_KEY": "your_api_key"
      }
    }
  }
}

You can also add via Cursor Settings → Tools & Integrations → New MCP Server and paste the JSON there.

You can now start a new chat and ask a question depending on the available tools.

Prompt injection risk

You're responsible for guarding against prompt injection when you use these tools. Exercise extreme caution, or use MCP tools only on Nium objects you trust.

Your first prompt​

After setup, confirm that your AI client is connected by sending a prompt that mentions Nium explicitly:

Using Nium, what APIs do I need to send a payout from Singapore to the US?

If the response references specific Nium endpoints and corridor requirements, you're connected.

Claude response to the Singapore to US payout prompt, listing the six Nium APIs to call in order and the supporting APIs

Once you're connected, try one of these prompts next:

Explore what's possible:

What payout corridors from the UK settle same-day, and what are the cutoff times?

Run a Sandbox workflow:

Create a corporate customer in my Nium Sandbox called Meridian Logistics, complete their KYC, add a USD beneficiary with routing number 021000021 and account 12345678, fund the wallet with 5,000 GBP, and send a 1,000 GBP payout.

Generate implementation code:

Generate a TypeScript function that creates a Nium customer, completes KYC, and returns the customer hash. Add error handling for the most common failure states.

How the Nium MCP Server works​

Once the Nium MCP Server is connected, you can use any supported AI client to work with Nium APIs in natural language. Each request follows the same four steps:

  1. Your prompt: You describe what you want in plain language. For example, "Create a corporate customer in my Sandbox" or "Send a 1,000 GBP payout to a beneficiary in the US."
  2. AI client: Your AI client, such as Claude, Cursor, or VS Code, passes your prompt to the Nium MCP Server.
  3. Nium MCP Server: The server uses function calling to translate your prompt into the Nium API operations needed to complete the task. It selects the right tool and fills in the request using the Nium API specification.
  4. Nium API request: The server sends the requests to the Nium Sandbox API and returns the results to your AI client, which presents them in your conversation.
note

Your AI client can ask you to confirm before the Nium MCP Server runs a write action, such as creating a customer or sending a payout. Review each action before you approve it.

Use Cases​

Generate production-ready Nium integration code directly from natural language prompts

The problem: Integrating a payments API means reading the reference, working out the right call sequence, and writing boilerplate. General-purpose AI tools make it faster to write code, but they often invent endpoints or field names, and you only find out when a request fails.

With the Nium MCP Server, your agent builds against Nium's pinned API specification, guides, and corridor data. Use it to start a new app or to add Nium to one you already have.

Start from scratch:

Build a complete Global Payroll Demo application using the Nium MCP Server as the source of truth. Keep the design clean and visual, with minimal text.

Add Nium to an existing codebase:

Look at how my app handles payments today. Using the Nium MCP Server as the source of truth, add Nium payouts: create beneficiaries, send payouts, and handle payout status webhooks. Follow my existing project structure and conventions.

What you get:

  • Working code in the language and framework you choose, such as Node.js, Python, or a React front end.
  • Request bodies that use the exact field names and the country-specific fields from the API spec.
  • Webhook handling based on Nium's integration guides.
  • Code that fits your existing structure, when you work from an agent that can read your project.
tip

To add Nium to an existing codebase, use an agent that can read your project files, such as Cursor, Claude Code, or VS Code.

Plan your integration before you build

The problem: Nium has many products and APIs. Working out which ones fit your business, in what order, and with which prerequisites usually means hopping between the API reference, guides, and corridor tables, or waiting on a call.

Try asking:

I run a US marketplace and need to pay freelancers in India and the Philippines. Which Nium APIs do I need, in what order, and what do I need to collect from each beneficiary before the first payout?
We're a travel platform that refunds customers in 20 countries and pays out to local suppliers. Which Nium products and APIs would you combine, and what should I check before building?

What you get:

  • The ordered API sequence for onboarding, funding, beneficiary creation, and payout.
  • Prerequisites for each step and the mandatory fields for each destination country.
  • A recommended architecture, with the trade-offs and open questions to resolve first.
Find out if a corridor works before you build for it

The problem: Discovering late in a project that a country, currency, or payout rail isn't supported, or that a cutoff or limit breaks your flow, is expensive.

Try asking:

Can I send USD from the US to India? Which payout methods, cutoff times, and limits apply, and which beneficiary fields are mandatory for each method?

What you get:

  • Available rails per corridor.
  • Cutoff times and limits.
  • The exact remitter and beneficiary fields you'll need to collect.
Run a full money-movement flow in Sandbox, without writing code

The problem: Proving that a flow works usually means writing scripts, juggling IDs between calls, and debugging before you've seen a single payout go through.

Try asking:

For my client `<insert ClientHashId>`, onboard a corporate customer in the US called Acme Corp and skip KYC in Sandbox. Add 500 USD to their USD wallet, add Jane Doe as a beneficiary with a bank account in India (ask me for any details you need), pay Jane 50 USD, and tell me when the payout completes.

What you get:

  • Customer, wallet, beneficiary, and payout created in Sandbox in one conversation.
  • Your assistant carries IDs between steps and asks only for what's missing.
  • A status check on the transaction at the end.
warning

Sandbox writes are real Sandbox operations. Review each action before you confirm it.

Fix a failing request in minutes, not support-ticket days

The problem: A validation error on a beneficiary or payout request can take hours to decode, especially when the cause is a country-specific field.

Try asking:

My Create Beneficiary request for a US bank account returns this error: `<paste the error and your request body>`. Compare it with the Nium spec and tell me exactly what's wrong and how to fix it.

What you get:

  • The mismatch between your request and the spec.
  • A corrected request body.
  • A Sandbox read-back to confirm the fix, if you ask for one.

Next steps​

Can't find what you need? Email us at developers@nium.com.

LLM-ready documentation:: llms.txt and llms-full.txt
Was this page helpful?