Building AI Integrations with Yuno's LLMs and MCP

Yuno offers tools to help you build AI-aware and merchant-friendly payment experiences. Yuno’s machine-ready documentation makes it easier for large language models (LLMs) to understand Yuno’s APIs and documentation, while Yuno’s Model Context Protocol (MCP) lets you integrate Yuno’s capabilities directly into your product. This guide introduces how to work with both components: how the LLM layer helps AI tools deliver more accurate and contextual integration support, and how the MCP embeds key payment and merchant functionality directly into your environment.

Looking for the one-click Claude/ChatGPT connector instead of building your own MCP client? See Use Yuno with Claude and ChatGPT.

Just need an agent to search and read Yuno’s documentation, with no API credentials and no ability to act on your account? See the read-only Documentation MCP instead.

Machine-ready content in plain text

To help large language models understand and support Yuno integrations, Yuno provides a dedicated set of Markdown (.md) files designed specifically for machine readability. These files describe Yuno’s APIs, product behavior, and implementation details in a format that’s easy for LLMs to parse and analyze. The .md files are part of Yuno Docs. You can access them by adding .md to the end of any Yuno Docs URL (this works for both Guides and API Reference pages). The content is served in plain text, making it easier for machines to extract and process the underlying knowledge without requiring human interpretation. This setup enables AI assistants, developer tools, and chat-based agents to answer questions, explain features, and guide integrations automatically.

Looking for a managed, network-accessible MCP endpoint with IP binding, rate limits, and session TTLs? See the remote Yuno MCP server.

Yuno’s Model Context Protocol (MCP)

This package provides an MCP server that exposes the Yuno payment platform API as Model Context Protocol tools. It enables programmatic access for AI agents, automation systems, and other advanced workflows that rely on structured, machine-readable context.

Features

Exposes Yuno API endpoints as MCP tools: Each endpoint is modeled as a tool that agents can call programmatically, with clear input and output structures
Enables AI and automation workflows with Yuno: Integrate Yuno into local agents or custom workflows without complex, handcrafted logic
Easy integration with Cursor and other MCP-compatible agents: Works out of the box with tools like Cursor, Claude Code, Claude Desktop, Codex, and other environments that support the Model Context Protocol

Available tools

The Yuno MCP server makes the following tools available to AI agents and automation:

Tool name	Description
`customerCreate`	Create a new customer
`customerRetrieve`	Retrieve a customer by ID
`customerRetrieveByExternalId`	Retrieve a customer by external ID (`merchant_customer_id`)
`customerUpdate`	Update an existing customer by ID
`paymentMethodEnroll`	Enroll or create payment method for a customer
`paymentMethodRetrieve`	Retrieve payment method
`paymentMethodRetrieveEnrolled`	Retrieve all enrolled payment methods for a customer
`paymentMethodUnenroll`	Unenroll payment method
`checkoutSessionCreate`	Create a checkout session
`checkoutSessionCreateOtt`	Generate a One Time Token (OTT) for a checkout session
`checkoutSessionRetrievePaymentMethods`	Retrieve payment methods for checkout
`paymentCreate`	Create a payment with various workflows
`paymentRetrieve`	Retrieve payment information
`paymentRetrieveByMerchantOrderId`	Retrieve payment(s) by `merchant_order_id`
`paymentRefund`	Refund a payment (full or partial) by payment and transaction ID
`paymentCancelOrRefund`	Cancel or refund a payment by payment ID (auto-detects action)
`paymentCancelOrRefundWithTransaction`	Cancel or refund a payment by payment and transaction ID (auto-detects action)
`paymentCancel`	Cancel a pending payment by payment and transaction ID
`paymentAuthorize`	Authorize a payment (`capture: false`)
`paymentCaptureAuthorization`	Capture a previously authorized payment
`paymentLinkCreate`	Create a new payment link
`paymentLinkRetrieve`	Retrieve a payment link by ID
`paymentLinkCancel`	Cancel a payment link by ID
`subscriptionCreate`	Create a new subscription
`subscriptionRetrieve`	Retrieve a subscription by ID
`subscriptionPause`	Pause a subscription by ID
`subscriptionResume`	Resume a subscription by ID
`subscriptionUpdate`	Update a subscription by ID
`subscriptionCancel`	Cancel a subscription by ID
`recipientCreate`	Create a new recipient
`recipientRetrieve`	Retrieve a recipient by ID
`recipientUpdate`	Update a recipient by ID
`recipientDelete`	Delete a recipient by ID
`installmentPlanCreate`	Create a new installment plan
`installmentPlanRetrieve`	Retrieve an installment plan by ID
`installmentPlanRetrieveAll`	Retrieve all installment plans for an account
`installmentPlanUpdate`	Update an installment plan by ID
`installmentPlanDelete`	Delete an installment plan by ID
`documentationRead`	Access Yuno API documentation and guides

The Remote Yuno MCP Server accepts snake_case tool arguments only. An unknown key such as idempotencyKey is rejected, and the error names idempotency_key. paymentAuthorize places a hold or refuses the call with UNSUPPORTED_AUTHORIZATION.

Using the MCP with Cursor, Claude Code, Claude Desktop, or Codex

You can use this MCP server with Cursor, Claude Code, Claude Desktop, or Codex to enable AI-driven payment flows, customer creation, and more.

1. Set up your Yuno API credentials

Set your Yuno API credentials using environment variables (see config examples below).

2. Add the MCP server to your client

Cursor
Claude Code
Claude Desktop
Codex

Open Cursor Settings (Cmd+Shift+P → “Cursor Settings”)
Go to the MCP section and click Add new global MCP server
Add the following config:

{
  "mcpServers": {
    "yuno-mcp": {
      "command": "npx",
      "args": ["@yuno-payments/yuno-mcp@latest"],
      "env": {
        "YUNO_ACCOUNT_CODE": "your_account_code",
        "YUNO_PUBLIC_API_KEY": "your_public_api_key",
        "YUNO_PRIVATE_SECRET_KEY": "your_private_secret_key",
        "YUNO_COUNTRY_CODE": "your_country_code",
        "YUNO_CURRENCY": "your_currency"
      }
    }
  }
}

Run:

claude mcp add yuno-mcp \
  -e YUNO_ACCOUNT_CODE=your_account_code \
  -e YUNO_PUBLIC_API_KEY=your_public_api_key \
  -e YUNO_PRIVATE_SECRET_KEY=your_private_secret_key \
  -e YUNO_COUNTRY_CODE=your_country_code \
  -e YUNO_CURRENCY=your_currency \
  -- npx @yuno-payments/yuno-mcp@latest

Use --scope project instead of the default local scope to share this server with your team via .mcp.json. Never commit real credentials: in .mcp.json, write each value as a reference such as "YUNO_PRIVATE_SECRET_KEY": "${YUNO_PRIVATE_SECRET_KEY}", so Claude Code reads it from each developer’s shell environment.

Open Claude Desktop settings → “Developer” tab → Edit Config.
Add the following config:

{
  "mcpServers": {
    "yuno-mcp": {
      "command": "npx",
      "args": ["@yuno-payments/yuno-mcp@latest"],
      "env": {
        "YUNO_ACCOUNT_CODE": "your_account_code",
        "YUNO_PUBLIC_API_KEY": "your_public_api_key",
        "YUNO_PRIVATE_SECRET_KEY": "your_private_secret_key",
        "YUNO_COUNTRY_CODE": "your_country_code",
        "YUNO_CURRENCY": "your_currency"
      }
    }
  }
}

Run:

codex mcp add yuno-mcp \
  --env YUNO_ACCOUNT_CODE=your_account_code \
  --env YUNO_PUBLIC_API_KEY=your_public_api_key \
  --env YUNO_PRIVATE_SECRET_KEY=your_private_secret_key \
  --env YUNO_COUNTRY_CODE=your_country_code \
  --env YUNO_CURRENCY=your_currency \
  -- npx @yuno-payments/yuno-mcp@latest

3. Test the integration

In your client, select a Markdown file or chat and ask the agent to create a payment, customer, or checkout session using the yuno-mcp tool
Make sure your environment variables are set correctly

Environment variables

YUNO_ACCOUNT_CODE*
YUNO_PUBLIC_API_KEY*
YUNO_PRIVATE_SECRET_KEY*
YUNO_COUNTRY_CODE (optional)
YUNO_CURRENCY (optional)

Asterisk (*) marks required.

Support

For official Yuno support, please visit Yuno’s official documentation

Getting Started

Core Concepts

Using Yuno

Direct Integration Use Cases

Payment Features

Payouts and Disputes

Webhooks

Wallets

AI Capabilities

Security and Compliance

Plugins

Additional Services

Building AI Integrations with Yuno's LLMs and MCP

Machine-ready content in plain text

Yuno’s Model Context Protocol (MCP)

Features

Available tools

Using the MCP with Cursor, Claude Code, Claude Desktop, or Codex

1. Set up your Yuno API credentials

2. Add the MCP server to your client

3. Test the integration

Environment variables

Support

​Machine-ready content in plain text

​Yuno’s Model Context Protocol (MCP)

​Features

​Available tools

​Using the MCP with Cursor, Claude Code, Claude Desktop, or Codex

​1. Set up your Yuno API credentials

​2. Add the MCP server to your client

​3. Test the integration

​Environment variables

​Support

Machine-ready content in plain text

Yuno’s Model Context Protocol (MCP)

Features

Available tools

Using the MCP with Cursor, Claude Code, Claude Desktop, or Codex

1. Set up your Yuno API credentials

2. Add the MCP server to your client

3. Test the integration

Environment variables

Support