> ## Documentation Index
> Fetch the complete documentation index at: https://docs.y.uno/llms.txt
> Use this file to discover all available pages before exploring further.

> ## Agent Instructions
> Test in the sandbox first: base URL https://api-sandbox.y.uno (Test Mode in the Dashboard). Production is https://api.y.uno (Live Mode).
> Every API request needs the public-api-key and private-secret-key headers. Get them in the Dashboard at https://dashboard.y.uno/developers (Developers > Credentials); sandbox and production keys are different.
> Send an X-Idempotency-Key (a UUID) when creating payments, refunds and cancels, so retries do not create duplicates.
> Start with the Quickstart (https://docs.y.uno/docs/quickstart.md) and the agent guide (https://docs.y.uno/agents.md). To search these docs from a coding agent, connect the docs MCP server at https://docs.y.uno/mcp.

# Creación de integraciones de IA con los LLM y el MCP de Yuno

> Expone los endpoints de la API de Yuno como herramientas MCP y documentación legible por máquinas para integraciones impulsadas por LLM

Yuno ofrece herramientas para ayudarte a crear experiencias de pago preparadas para la IA y amigables para el comercio. La documentación lista para máquinas de Yuno facilita que los modelos de lenguaje de gran tamaño (LLM) comprendan las API y la documentación de Yuno, mientras que el Model Context Protocol (MCP) de Yuno te permite integrar las capacidades de Yuno directamente en tu producto.

Esta guía presenta cómo trabajar con ambos componentes: cómo la capa de LLM ayuda a las herramientas de IA a ofrecer un soporte de integración más preciso y contextual, y cómo el MCP incorpora las funciones clave de pagos y de comercio directamente en tu entorno.

> [!NOTE]
>
> ¿Buscas el conector de un clic en lugar de crear tu propio cliente MCP? Consulta [Usa Yuno con asistentes de IA](https://docs.y.uno/es/docs/ai-capabilities/use-yuno-with-claude-and-chatgpt.md).

> [!NOTE]
>
> ¿Solo necesitas que un agente busque y lea la documentación de Yuno, sin credenciales de API y sin capacidad de actuar sobre tu cuenta? Consulta en su lugar el [MCP de documentación](https://docs.y.uno/setup-mcp.md) de solo lectura.

## Contenido listo para máquinas en texto plano

Para ayudar a los modelos de lenguaje de gran tamaño a comprender y respaldar las integraciones con Yuno, Yuno proporciona un conjunto dedicado de archivos Markdown (.md) diseñados específicamente para que las máquinas los lean. Estos archivos describen las API de Yuno, el comportamiento del producto y los detalles de implementación en un formato que los LLM pueden analizar con facilidad.

Los archivos .md forman parte de [Yuno Docs](https://docs.y.uno/index.md). Puedes acceder a ellos agregando .md al final de cualquier URL de Yuno Docs (esto funciona tanto para las páginas de Guías como para las de API Reference). El contenido se sirve en texto plano, lo que facilita que las máquinas extraigan y procesen el conocimiento subyacente sin necesidad de interpretación humana.

Esta configuración permite que los asistentes de IA, las herramientas para desarrolladores y los agentes basados en chat respondan preguntas, expliquen funciones y guíen las integraciones de forma automática.

> [!NOTE]
>
> ¿Buscas un endpoint MCP administrado y accesible por red, con vinculación de IP, límites de frecuencia y TTL de sesión? Consulta el [servidor MCP remoto de Yuno](https://docs.y.uno/es/docs/ai-capabilities/remote-yuno-mcp-server.md).

## Model Context Protocol (MCP) de Yuno

Este paquete proporciona un servidor MCP que expone la API de la plataforma de pagos de Yuno como herramientas del Model Context Protocol. Permite el acceso programático para agentes de IA, sistemas de automatización y otros flujos de trabajo avanzados que dependen de un contexto estructurado y legible por máquinas.

### Características

* **Expone los endpoints de la API de Yuno como herramientas MCP**: cada endpoint se modela como una herramienta que los agentes pueden llamar de forma programática, con estructuras de entrada y salida claras

* **Habilita flujos de trabajo de IA y automatización con Yuno**: integra Yuno en agentes locales o flujos de trabajo personalizados sin lógica compleja creada a mano

* **Integración sencilla con Cursor y otros agentes compatibles con MCP**: funciona de inmediato con herramientas como Cursor, Claude Code, Claude Desktop, Codex y otros entornos que admiten el Model Context Protocol

### Herramientas disponibles

El servidor MCP de Yuno pone las siguientes herramientas a disposición de los agentes de IA y la automatización:

| Nombre de la herramienta | Descripción |
| - | - |
| `customerCreate` | Crear un nuevo cliente |
| `customerRetrieve` | Obtener un cliente por ID |
| `customerRetrieveByExternalId` | Obtener un cliente por ID externo (`merchant_customer_id`) |
| `customerUpdate` | Actualizar un cliente existente por ID |
| `paymentMethodEnroll` | Inscribir o crear un método de pago para un cliente |
| `paymentMethodRetrieve` | Obtener un método de pago |
| `paymentMethodRetrieveEnrolled` | Obtener todos los métodos de pago inscritos de un cliente |
| `paymentMethodUnenroll` | Cancelar la inscripción de un método de pago |
| `checkoutSessionCreate` | Crear una sesión de checkout |
| `checkoutSessionCreateOtt` | Generar un One Time Token (OTT) para una sesión de checkout |
| `checkoutSessionRetrievePaymentMethods` | Obtener los métodos de pago para el checkout |
| `paymentCreate` | Crear un pago con distintos flujos de trabajo |
| `paymentRetrieve` | Obtener la información de un pago |
| `paymentRetrieveByMerchantOrderId` | Obtener uno o varios pagos por `merchant_order_id` |
| `paymentRefund` | Reembolsar un pago (total o parcial) por ID de pago y de transacción |
| `paymentCancelOrRefund` | Cancelar o reembolsar un pago por ID de pago (detecta la acción automáticamente) |
| `paymentCancelOrRefundWithTransaction` | Cancelar o reembolsar un pago por ID de pago y de transacción (detecta la acción automáticamente) |
| `paymentCancel` | Cancelar un pago pendiente por ID de pago y de transacción |
| `paymentAuthorize` | Autorizar un pago (`capture: false`) |
| `paymentCaptureAuthorization` | Capturar un pago previamente autorizado |
| `paymentLinkCreate` | Crear un nuevo enlace de pago |
| `paymentLinkRetrieve` | Obtener un enlace de pago por ID |
| `paymentLinkCancel` | Cancelar un enlace de pago por ID |
| `subscriptionCreate` | Crear una nueva suscripción |
| `subscriptionRetrieve` | Obtener una suscripción por ID |
| `subscriptionPause` | Pausar una suscripción por ID |
| `subscriptionResume` | Reanudar una suscripción por ID |
| `subscriptionUpdate` | Actualizar una suscripción por ID |
| `subscriptionCancel` | Cancelar una suscripción por ID |
| `recipientCreate` | Crear un nuevo destinatario |
| `recipientRetrieve` | Obtener un destinatario por ID |
| `recipientUpdate` | Actualizar un destinatario por ID |
| `recipientDelete` | Eliminar un destinatario por ID |
| `installmentPlanCreate` | Crear un nuevo plan de cuotas |
| `installmentPlanRetrieve` | Obtener un plan de cuotas por ID |
| `installmentPlanRetrieveAll` | Obtener todos los planes de cuotas de una cuenta |
| `installmentPlanUpdate` | Actualizar un plan de cuotas por ID |
| `installmentPlanDelete` | Eliminar un plan de cuotas por ID |
| `documentationRead` | Acceder a la documentación y las guías de la API de Yuno |

> [!NOTE]
>
> El [servidor MCP remoto de Yuno](https://docs.y.uno/es/docs/ai-capabilities/remote-yuno-mcp-server.md) solo acepta argumentos de herramientas en snake\_case. Una clave desconocida como `idempotencyKey` se rechaza, y el error indica `idempotency_key`. `paymentAuthorize` retiene el monto o rechaza la llamada con `UNSUPPORTED_AUTHORIZATION`.

## Uso del MCP con Cursor, Claude Code, Claude Desktop o Codex

Puedes usar este servidor MCP con Cursor, Claude Code, Claude Desktop o Codex para habilitar flujos de pago impulsados por IA, creación de clientes y más.

### Configura tus credenciales de la API de Yuno

Configura tus credenciales de la API de Yuno mediante variables de entorno (consulta los ejemplos de configuración más abajo).

### Agrega el servidor MCP a tu cliente

> [tab] Cursor
>
> * Abre Cursor Settings (`Cmd+Shift+P` → "Cursor Settings")
> * Ve a la sección **MCP** y haz clic en **Add new global MCP server**
> * Agrega la siguiente configuración:
>
> ```json theme={"theme":{"light":"github-dark","dark":"github-dark-dimmed"}}
> {
>   "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"
>       }
>     }
>   }
> }
> ```

> [tab] Claude Code
>
> Ejecuta:
>
> ```bash theme={"theme":{"light":"github-dark","dark":"github-dark-dimmed"}}
> 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
> ```
>
> Usa `--scope project` en lugar del alcance `local` predeterminado para compartir este servidor con tu equipo mediante `.mcp.json`. Nunca confirmes credenciales reales: en `.mcp.json`, escribe cada valor como una referencia, por ejemplo `"YUNO_PRIVATE_SECRET_KEY": "${YUNO_PRIVATE_SECRET_KEY}"`, para que Claude Code lo lea del entorno de shell de cada desarrollador.

> [tab] Claude Desktop
>
> * Abre la configuración de Claude Desktop → pestaña "Developer" → Edit Config.
> * Agrega la siguiente configuración:
>
> ```json theme={"theme":{"light":"github-dark","dark":"github-dark-dimmed"}}
> {
>   "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"
>       }
>     }
>   }
> }
> ```

> [tab] Codex
>
> Ejecuta:
>
> ```bash theme={"theme":{"light":"github-dark","dark":"github-dark-dimmed"}}
> 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
> ```

### Prueba la integración

* En tu cliente, selecciona un archivo Markdown o un chat y pide al agente que cree un pago, un cliente o una sesión de checkout usando la herramienta yuno-mcp
* Asegúrate de que tus variables de entorno estén configuradas correctamente

## Variables de entorno

* `YUNO_ACCOUNT_CODE`\*
* `YUNO_PUBLIC_API_KEY`\*
* `YUNO_PRIVATE_SECRET_KEY`\*
* `YUNO_COUNTRY_CODE` (opcional)
* `YUNO_CURRENCY` (opcional)

El asterisco (\*) indica que es obligatorio.

## Soporte

* Para obtener soporte oficial de Yuno, visita la [documentación oficial de Yuno](https://docs.y.uno/index.md)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.