Pinelabs MCP Server

El servidor MCP de Pine Labs Online implementa el Protocolo de Contexto del Modelo (MCP) para permitir una integración fluida entre las API de pago en línea de Pine Labs y las herramientas de IA. Permite que los asistentes de IA realicen operaciones de la API en línea de Pine Labs, lo que facilita a los desarrolladores la creación de aplicaciones de pago inteligentes impulsadas por IA.

GitHub

Prueba este MCPPatrocinado

Documentación

Servidor MCP de Pine Labs Payment Gateway (Oficial)

Cliente MCP para la pasarela de pagos de Pine Labs: conecta Claude Desktop, Cursor, VS Code y otros asistentes de IA a las API de pago de Pine Labs usando tus credenciales de cliente.

Documentación completa | Herramientas disponibles | Casos de uso | Preguntas frecuentes

Requisitos previos

Node.js 18+ -- Descargar o instalar npm i pinelabs-mcp
Credenciales de cliente de Pine Labs -- Obtén tu Client ID y Client Secret desde el portal para desarrolladores de Pine Labs

Inicio rápido

Obtención de tus credenciales

Regístrate o inicia sesión en el panel del comerciante de Pine Labs proporcionado con tu cuenta.
Navega a la configuración de tu cuenta para localizar tu Client ID y Client Secret.
Usa estas credenciales en la configuración del servidor MCP como se muestra en las instrucciones de configuración anteriores.

Configurar y conectar

# 1. Configure your credentials
npx pinelabs-mcp configure --client-id=YOUR_ID --client-secret=YOUR_SECRET

# 2. Test your connection
npx pinelabs-mcp test

# 3. Auto-configure your AI client
npx pinelabs-mcp setup cursor       # or: claude-desktop, vscode, windsurf, opencode, copilot, codex

Luego reinicia tu cliente de IA y comienza a usar las herramientas de Pine Labs.

Comandos CLI

pinelabs-mcp start                             Start MCP server (stdio mode)
pinelabs-mcp configure                         Interactive credential setup
pinelabs-mcp configure --client-id=X --client-secret=Y [--env=uat|prod]
pinelabs-mcp test                              Test connectivity and credentials
pinelabs-mcp setup <client>                    Auto-configure an AI client
pinelabs-mcp setup <client> --local            Use local path (dev mode)
pinelabs-mcp setup <client> --print            Preview config without writing
pinelabs-mcp status                            Show current configuration
pinelabs-mcp help                              Show help message
pinelabs-mcp --version                         Show version

Clientes de IA compatibles

Cliente	Comando	Ruta de configuración
Claude Desktop	`setup claude-desktop`	Configuración de Claude específica de la plataforma
Cursor	`setup cursor`	`~/.cursor/mcp.json`
VS Code	`setup vscode`	`.vscode/mcp.json` (proyecto)
Windsurf	`setup windsurf`	`~/.codeium/windsurf/mcp_config.json`
OpenCode	`setup opencode`	`.opencode/config.json` (proyecto)
GitHub Copilot	`setup copilot`	`~/.copilot/mcp-config.json`
OpenAI Codex	`setup codex`	`.codex/config.toml`

Configuración manual

Si prefieres configurar manualmente en lugar de usar npx pinelabs-mcp setup, agrega lo siguiente a la configuración MCP de tu cliente de IA:

{
  "mcpServers": {
    "pinelabs": {
      "command": "npx",
      "args": ["-y", "pinelabs-mcp"],
      "env": {
        "PINELABS_CLIENT_ID": "your_client_id",
        "PINELABS_CLIENT_SECRET": "your_client_secret"
      }
    }
  }
}

Nota: VS Code usa "servers" en lugar de "mcpServers" como clave de nivel superior. Para el entorno de producción, agrega "PINELABS_ENV": "prod" al bloque env.

Herramientas disponibles

El servidor MCP de Pine Labs expone más de 50 herramientas en múltiples categorías. Cada herramienta se asigna a un endpoint específico de la API de pagos de Pine Labs.

Leyenda de tipos de herramienta

Cada herramienta a continuación está etiquetada con un Tipo que indica su patrón de acceso y riesgo operativo. Esto te ayuda a razonar sobre qué herramientas son seguras en implementaciones de solo lectura y cuáles requieren confirmación explícita del usuario en flujos autónomos (agénticos).

Tipo	Significado	Ejemplos
Lectura	Seguro, sin efectos secundarios. Solo obtiene o consulta datos. Permitido en modo de solo lectura.	`get_order_by_order_id`, `get_all_settlements`, `list_plural_apis`
Escritura	Crea o modifica recursos. No es destructivo pero muta el estado del servidor. Se omite en modo de solo lectura.	`create_payment_link`, `create_order`, `update_plan`
Destructivo	Cancela, elimina, reembolsa o mueve dinero. Irreversible o con impacto financiero. Debe requerir confirmación explícita del usuario en flujos de agente.	`cancel_order`, `create_refund`, `create_payout`, `delete_plan`

Modo de solo lectura: Ejecuta el servidor con --read-only (o establece la configuración equivalente) para registrar solo las herramientas Read y omitir todos los conjuntos de herramientas Write / Destructive. Útil para análisis, monitoreo o contextos de agente no confiables.

Enlaces de pago

Herramienta	Tipo	Descripción	Referencia de API
`create_payment_link`	Escritura	Crea un nuevo enlace de pago para cobrar pagos	Enlace de pago - Crear
`get_payment_link_by_id`	Lectura	Obtiene un enlace de pago por su ID de enlace de pago	Enlace de pago - Obtener por ID
`get_payment_link_by_merchant_reference`	Lectura	Obtiene un enlace de pago por su referencia de enlace de pago del comerciante	Enlace de pago - Obtener por referencia
`cancel_payment_link`	Destructivo	Cancela un enlace de pago activo	Enlace de pago - Cancelar
`resend_payment_link_notification`	Escritura	Reenvía una notificación de enlace de pago al cliente	Enlace de pago - Reenviar

Pedidos

Herramienta	Tipo	Descripción	Referencia de API
`get_order_by_order_id`	Lectura	Recupera los detalles del pedido por ID de pedido	Pedido - Obtener por ID
`get_order_by_merchant_order_reference`	Lectura	Recupera los detalles del pedido por referencia de pedido del comerciante	Pedido - Obtener por referencia del comerciante
`capture_order`	Escritura	Captura un pago previamente autorizado contra un pedido	Pedido - Capturar
`cancel_order`	Destructivo	Cancela un pago preautorizado contra un pedido	Pedido - Cancelar
`fetch_order_payments`	Lectura	Obtiene todos los intentos de pago asociados con un pedido	Pedido - Obtener pagos

Pedidos de checkout

Herramienta	Tipo	Descripción	Referencia de API
`create_order`	Escritura	Crea un nuevo pedido de checkout y genera un enlace de checkout	Pedido - Crear

Pagos con tarjeta

Herramienta	Tipo	Descripción	Referencia de API
`create_card_payment`	Escritura	Crea un pago con tarjeta de servidor a servidor contra un pedido	Pago con tarjeta - Crear
`get_card_details`	Lectura	Recupera los detalles de la tarjeta (BIN, red, tipo) para un número de tarjeta	Detalles de tarjeta - Obtener

OTP

Herramienta	Tipo	Descripción	Referencia de API
`generate_otp`	Escritura	Genera un OTP para un flujo de autenticación de pago con tarjeta	OTP - Generar
`submit_otp`	Escritura	Envía un OTP para completar la autenticación de un pago con tarjeta	OTP - Enviar
`resend_otp`	Escritura	Reenvía un OTP para la autenticación de un pago con tarjeta	OTP - Reenviar

Reembolsos

Herramienta	Tipo	Descripción	Referencia de API
`create_refund`	Destructivo	Inicia un reembolso total o parcial contra un pago capturado	Reembolso - Crear

Liquidaciones

Herramienta	Tipo	Descripción	Referencia de API
`get_all_settlements`	Lectura	Recupera todas las liquidaciones del comerciante dentro de un rango de fechas	Liquidaciones - Obtener todas
`get_settlement_by_utr`	Lectura	Recupera una liquidación específica por su UTR (Referencia Única de Transacción)	Liquidación - Obtener por UTR

Payouts

Herramienta	Tipo	Descripción	Referencia de API
`create_payout`	Destructivo	Crea un payout para desembolsar fondos a un beneficiario (mueve dinero)	Payout - Crear
`get_payout_details`	Lectura	Recupera los detalles de un payout por ID de payout	Payout - Obtener
`get_payout_payments`	Lectura	Lista los pagos asociados con un payout	Payout - Obtener pagos
`get_payout_balance`	Lectura	Recupera el saldo de payout disponible para el comerciante	Payout - Obtener saldo
`update_payout`	Escritura	Actualiza una solicitud de payout existente	Payout - Actualizar
`cancel_payout`	Destructivo	Cancela una solicitud de payout pendiente	Payout - Cancelar

Suscripciones

Herramienta	Tipo	Descripción	Referencia de API
`create_plan`	Escritura	Crea un nuevo plan de suscripción	Plan - Crear
`get_plans`	Lectura	Recupera los planes de suscripción	Plan - Obtener todos
`get_plan_by_id`	Lectura	Recupera un plan de suscripción por ID de plan	Plan - Obtener específico
`get_plan_by_merchant_reference`	Lectura	Recupera un plan por referencia de plan del comerciante	Plan - Obtener específico
`update_plan`	Escritura	Actualiza un plan de suscripción existente	Plan - Actualizar
`delete_plan`	Destructivo	Elimina un plan de suscripción	Plan - Eliminar
`create_subscription`	Escritura	Crea una nueva suscripción contra un plan	Suscripción - Crear
`get_subscriptions`	Lectura	Recupera las suscripciones	Suscripción - Obtener todas
`get_subscription_by_id`	Lectura	Recupera una suscripción por ID de suscripción	Suscripción - Obtener específica
`get_subscription_by_merchant_reference`	Lectura	Recupera una suscripción por referencia del comerciante	Suscripción - Obtener específica
`pause_subscription`	Escritura	Pausa una suscripción activa	Suscripción - Pausar
`resume_subscription`	Escritura	Reanuda una suscripción pausada	Suscripción - Reanudar
`cancel_subscription`	Destructivo	Cancela una suscripción activa	Suscripción - Cancelar
`update_subscription`	Escritura	Actualiza una suscripción existente	Suscripción - Actualizar
`create_presentation`	Escritura	Crea una presentación (solicitud de pago) para una suscripción	Presentación - Crear
`get_presentation`	Lectura	Recupera una presentación por ID de presentación	Presentación - Obtener
`delete_presentation`	Destructivo	Elimina una presentación	Presentación - Eliminar
`get_presentations_by_subscription_id`	Lectura	Recupera todas las presentaciones de una suscripción	Presentación - Obtener por suscripción
`get_presentation_by_merchant_reference`	Lectura	Recupera una presentación por referencia del comerciante	Presentación - Obtener
`send_subscription_notification`	Escritura	Envía una notificación previa al débito para una suscripción	Presentación - Crear
`create_debit`	Destructivo	Ejecuta un débito (cobro de pago) contra una suscripción	Presentación - Crear
`create_merchant_retry`	Escritura	Reintenta la ejecución del mandato para un débito fallido (máximo 3 reintentos)	Reintento del comerciante

Pagos UPI

Herramienta	Tipo	Descripción	Referencia de API
`create_upi_intent_payment_with_qr`	Escritura	Crea un pago UPI intent con código QR para cobro instantáneo	UPI Intent QR

Informes y búsqueda de transacciones

Herramienta	Tipo	Descripción	Referencia de API
`get_payment_link_details`	Lectura	Obtiene los detalles de enlaces de pago dentro de un rango de fechas	Documentación de API
`get_order_details`	Lectura	Obtiene los detalles de pedidos dentro de un rango de fechas	Documentación de API
`get_refund_order_details`	Lectura	Obtiene los detalles de pedidos de reembolso dentro de un rango de fechas	Documentación de API
`search_transaction`	Lectura	Busca una transacción por ID de transacción	Documentación de API

Herramientas para desarrolladores

Herramienta	Tipo	Descripción
`get_api_documentation`	Lectura	Obtiene la documentación de la API de Pine Labs para una API específica
`list_plural_apis`	Lectura	Lista todas las API de Pine Labs (Plural) disponibles con descripciones
`detect_stack`	Lectura	Detecta la pila tecnológica del proyecto actual para adaptar la guía de integración
`integrate_pinelabs_checkout`	Lectura	Genera fragmentos de código conscientes de la pila y guía de integración para Pine Labs Checkout

Análisis del comerciante

Herramienta	Tipo	Descripción
`get_merchant_success_rate`	Lectura	Obtiene la tasa de éxito de transacciones del comerciante en un rango de fechas

Casos de uso

Integración de pasarela de pago: Conecta tu aplicación de IA a la pasarela de pago de Pine Labs para crear pedidos de pago, generar enlaces de pago y procesar transacciones de forma programática.
Flujos de pago impulsados por IA: Crea experiencias de pago conversacionales donde los asistentes de IA crean pedidos, generan enlaces de pago y rastrean el estado del pago en tiempo real.
Automatización de pagos UPI: Genera códigos QR de intención UPI y procesa pagos UPI a través de interfaces impulsadas por IA para cobros dentro de la aplicación o en el punto de venta.
Gestión del ciclo de vida de suscripciones: Automatiza la creación de planes de pago recurrentes, la activación de suscripciones, los ciclos de pausa/reanudación, las presentaciones de débito y las notificaciones previas al débito.
Flujos de pago agénticos: Crea agentes de IA autónomos que gestionen operaciones de pago de extremo a extremo, desde la creación de pedidos hasta la conciliación, sin intervención manual.
Seguimiento de pedidos y conciliación: Consulta detalles de pedidos, busca transacciones por ID y concilia pagos para verificar estados y resolver disputas.
Analítica e informes de pagos: Recupera informes de enlaces de pago, resúmenes de pedidos, detalles de reembolsos y tasas de éxito de comerciantes en rangos de fechas personalizados.
Automatización de soporte al cliente: Permite que los agentes de soporte o chatbots consulten transacciones, verifiquen estados de pago, cancelen pedidos y reenvíen notificaciones de pago.

Servidor MCP remoto

El servidor MCP remoto está alojado y mantenido por Pine Labs. Usa este enfoque si prefieres configurar tu cliente de IA manualmente con el endpoint remoto en lugar de usar la CLI de npm.

Beneficios

Cero configuración: No necesitas gestionar Python, Docker ni infraestructura local.
Siempre actualizado: Actualizaciones automáticas con las últimas funciones de la API de pagos y parches de seguridad.
Alta disponibilidad: Alojado en la infraestructura de producción de Pine Labs.
Autenticación segura: Autenticación de credenciales de cliente a través de HTTPS.

Si te conectas a una implementación remota autoalojada en lugar del servicio alojado de Pine Labs, reemplaza la URL remota a continuación con <your-mcp-server-url>.

Requisitos previos

Se requiere npx para actuar como proxy de la conexión MCP remota. Instala Node.js (que incluye npm y npx):

macOS

brew install node

Windows

choco install nodejs

Alternativamente, descárgalo desde https://nodejs.org/.

Verificar la instalación

npx --version

Uso con Cursor

Agrega lo siguiente a la configuración de MCP de Cursor:

{
  "mcpServers": {
    "pinelabs": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://mcp.pinelabs.com/mcp",
        "--header",
        "X-Client-Id:<your-client-id>",
        "--header",
        "X-Client-Secret:<your-client-secret>"
      ]
    }
  }
}

Reemplaza <your-client-id> y <your-client-secret> con tus credenciales de Pine Labs. Consulta Autenticación para más detalles.

Uso con Claude Desktop

Agrega lo siguiente a tu claude_desktop_config.json:

{
  "mcpServers": {
    "pinelabs": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://mcp.pinelabs.com/mcp",
        "--header",
        "X-Client-Id:<your-client-id>",
        "--header",
        "X-Client-Secret:<your-client-secret>"
      ]
    }
  }
}

Reemplaza <your-client-id> y <your-client-secret> con tus credenciales de Pine Labs.

Configura servidores MCP en Claude Desktop: Guía de inicio rápido de MCP
Instala Claude Desktop: Descargar

Uso con VS Code

Agrega lo siguiente a la configuración de VS Code (JSON):

{
  "mcp": {
    "inputs": [
      {
        "type": "promptString",
        "id": "pinelabs_client_id",
        "description": "Pine Labs Client ID"
      },
      {
        "type": "promptString",
        "id": "pinelabs_client_secret",
        "description": "Pine Labs Client Secret",
        "password": true
      }
    ],
    "servers": {
      "pinelabs": {
        "command": "npx",
        "args": [
          "mcp-remote",
          "https://mcp.pinelabs.com/mcp",
          "--header",
          "X-Client-Id:${input:pinelabs_client_id}",
          "--header",
          "X-Client-Secret:${input:pinelabs_client_secret}"
        ]
      }
    }
  }
}

Aprende más sobre servidores MCP en la documentación del modo agente de VS Code.

Autenticación

El servidor MCP se autentica usando credenciales de ID de cliente y Secreto de cliente emitidas por Pine Labs.

Nota: Para implementaciones locales, las credenciales se pueden pasar mediante argumentos de CLI o variables de entorno. Para el servidor remoto, las credenciales se pasan como encabezados HTTP.

Servidor MCP local

Implementa el servidor MCP en tu propia infraestructura para tener control total sobre el entorno de ejecución.

Requisitos previos

Python 3.12+
Docker (opcional, para implementación en contenedores)
Git

Instalar en Windows (Chocolatey)

La forma más rápida de obtener el servidor MCP en una máquina Windows es a través de Chocolatey. El paquete es un envoltorio delgado que instala Python 3.10+ como dependencia y luego instala pinelabs-mcp-server desde PyPI, registrando un shim de pinelabs-mcp en PATH.

choco install pinelabs-mcp

Verifica la instalación:

pinelabs-mcp --help

Ejecuta el servidor a través de stdio:

pinelabs-mcp stdio --client-id <your-client-id> --client-secret <your-client-secret> --env uat

Configuración del cliente MCP (Claude Desktop / Cursor / VS Code)

Después de choco install, apunta tu cliente MCP al shim de pinelabs-mcp:

{
  "mcpServers": {
    "pinelabs": {
      "command": "pinelabs-mcp",
      "args": ["stdio", "--env", "uat"],
      "env": {
        "PINELABS_CLIENT_ID": "<your-client-id>",
        "PINELABS_CLIENT_SECRET": "<your-client-secret>"
      }
    }
  }
}

Para desinstalar:

choco uninstall pinelabs-mcp

Usar imagen pública de Docker (recomendado)

Usa la imagen oficial de Docker de Pine Labs directamente. No se requiere paso de compilación.

Nota: Para fijar una versión específica, reemplaza pinelabs/mcp:latest con pinelabs/mcp:<version-tag> (por ejemplo, pinelabs/mcp:v1.0.0) en las configuraciones a continuación.

Uso con Claude Desktop

Agrega lo siguiente a tu claude_desktop_config.json:

{
  "mcpServers": {
    "pinelabs": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-i",
        "-e",
        "PINELABS_CLIENT_ID",
        "-e",
        "PINELABS_CLIENT_SECRET",
        "-e",
        "PINELABS_ENV",
        "pinelabs/mcp:latest"
      ],
      "env": {
        "PINELABS_CLIENT_ID": "<your-client-id>",
        "PINELABS_CLIENT_SECRET": "<your-client-secret>",
        "PINELABS_ENV": "prod"
      }
    }
  }
}

Reemplaza <your-client-id> y <your-client-secret> con tus credenciales de Pine Labs.

Configura servidores MCP en Claude Desktop: Guía de inicio rápido de MCP
Instala Claude Desktop: Descargar

Uso con VS Code

Agrega lo siguiente a la configuración de VS Code (JSON):

{
  "mcp": {
    "inputs": [
      {
        "type": "promptString",
        "id": "pinelabs_client_id",
        "description": "Pine Labs Client ID"
      },
      {
        "type": "promptString",
        "id": "pinelabs_client_secret",
        "description": "Pine Labs Client Secret",
        "password": true
      }
    ],
    "servers": {
      "pinelabs": {
        "command": "docker",
        "args": [
          "run",
          "--rm",
          "-i",
          "-e",
          "PINELABS_CLIENT_ID",
          "-e",
          "PINELABS_CLIENT_SECRET",
          "-e",
          "PINELABS_ENV=prod",
          "pinelabs/mcp:latest"
        ],
        "env": {
          "PINELABS_CLIENT_ID": "${input:pinelabs_client_id}",
          "PINELABS_CLIENT_SECRET": "${input:pinelabs_client_secret}"
        }
      }
    }
  }
}

Aprende más sobre servidores MCP en la documentación del modo agente de VS Code.

Uso con Cursor

{
  "mcpServers": {
    "pinelabs": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-i",
        "-e",
        "PINELABS_CLIENT_ID",
        "-e",
        "PINELABS_CLIENT_SECRET",
        "-e",
        "PINELABS_ENV=prod",
        "pinelabs/mcp:latest"
      ],
      "env": {
        "PINELABS_CLIENT_ID": "<your-client-id>",
        "PINELABS_CLIENT_SECRET": "<your-client-secret>"
      }
    }
  }
}

Reemplaza <your-client-id> y <your-client-secret> con tus credenciales de Pine Labs.

Compilar desde Docker (alternativa)

Clona el repositorio y compila la imagen de Docker localmente:

git clone https://github.com/plural-pinelabs/pinelabs-online-mcp.git
cd pinelabs-online-mcp
docker build -t pinelabs-mcp-server:latest .

Una vez compilada, reemplaza pinelabs/mcp:latest con pinelabs-mcp-server:latest en las configuraciones anteriores.

Compilar desde el código fuente

Ejecuta el servidor directamente desde el código fuente sin Docker:

# Clone the repository
git clone https://github.com/plural-pinelabs/pinelabs-online-mcp.git
cd pinelabs-online-mcp

# Create and activate a virtual environment
python -m venv .venv
source .venv/bin/activate      # macOS/Linux
# .venv\Scripts\activate       # Windows

# Install dependencies
pip install -r requirements.txt

# Run the server (stdio mode)
python -m cli.pinelabs_mcp_server.main stdio \
  --client-id <your-client-id> \
  --client-secret <your-client-secret> \
  --env prod

Una vez en ejecución, configura tu cliente MCP para conectarse al proceso local. Ejemplo para VS Code:

{
  "mcp": {
    "servers": {
      "pinelabs": {
        "command": "python",
        "args": [
          "-m",
          "cli.pinelabs_mcp_server.main",
          "stdio"
        ],
        "env": {
          "PINELABS_CLIENT_ID": "<your-client-id>",
          "PINELABS_CLIENT_SECRET": "<your-client-secret>",
          "PINELABS_ENV": "prod"
        }
      }
    }
  }
}

Configuración

Variables de entorno

Variable	Requerida	Predeterminada	Descripción
`PINELABS_CLIENT_ID`	Sí	--	ID de cliente de Pine Labs para autenticación de API
`PINELABS_CLIENT_SECRET`	Sí	--	Secreto de cliente de Pine Labs para autenticación de API
`PINELABS_ENV`	No	`uat`	Entorno de destino: `uat` o `prod`
`LOG_LEVEL`	No	`INFO`	Verbosidad de registro: `DEBUG`, `INFO`, `WARNING`, `ERROR`
`LOG_FILE`	No	stderr	Ruta al archivo de salida de registro
`READ_ONLY`	No	`false`	Restringir a herramientas de solo lectura (deshabilita operaciones de escritura)
`TOOLSETS`	No	all	Lista separada por comas de conjuntos de herramientas a habilitar

Banderas de línea de comandos

python -m cli.pinelabs_mcp_server.main <transport> [options]

Transports:
  stdio                 Standard I/O transport (for MCP clients)
  http                  HTTP transport (for web-based access)

Options:
  --client-id           Pine Labs client ID
  --client-secret       Pine Labs client secret
  --env                 Environment: uat, prod (default: uat)
  --log-file            Path to log file
  --log-level           Log level: DEBUG, INFO, WARNING, ERROR
  --read-only           Only register read-only tools
  --toolsets            Comma-separated list of toolsets to enable

HTTP-only options:
  --host                Host to bind to (default: 0.0.0.0)
  --port                Port to listen on (default: 8000)

Depuración del servidor

Usa la bandera --log-level DEBUG y opcionalmente --log-file para escribir registros detallados para la resolución de problemas:

python -m cli.pinelabs_mcp_server.main stdio \
  --client-id <ID> --client-secret <SECRET> \
  --log-level DEBUG --log-file ./debug.log

Preguntas frecuentes

P: ¿Necesito proporcionar montos en paisa? R: No. Los montos se especifican en rupias (por ejemplo, 500 para INR 500). No se requiere conversión a paisa.

P: ¿Qué entornos son compatibles? R: El servidor admite los entornos uat (predeterminado) y prod. Se configuran mediante PINELABS_ENV o --env.

P: ¿Puedo restringir qué herramientas están disponibles? R: Sí. Usa la bandera --read-only para deshabilitar operaciones de escritura, o usa --toolsets para habilitar conjuntos de herramientas específicos (por ejemplo, --toolsets payment_links,orders).

P: ¿Dónde puedo encontrar la referencia completa de la API? R: Visita la Documentación para desarrolladores de Pine Labs para la referencia completa de la API.

Palabras clave

Pine Labs, Pine Labs Online, Plural, Plural Online, pasarela de pago, pasarela de pago en línea, pasarela de pago, pago en línea, pago alojado, página de pago, pagos, pagos en línea, pagos digitales, procesamiento de pagos, aceptar pagos, cobrar pagos, integración de pagos, integración de pasarela, API de pagos, API de pago, API de pago, API de pasarela, UPI, tarjetas, tarjeta de crédito, tarjeta de débito, banca en línea, billetera, EMI, EMI sin tarjeta, suscripciones, pagos recurrentes, pedidos, pagos de pedidos, crear pago, iniciar pago, procesar pago, enlaces de pago, servidor MCP, Protocolo de contexto de modelo, automatización de pagos con IA, pagos agénticos, pagos con código QR, orquestación de pagos, API de comerciante, informes de transacciones, fintech, SDK

Licencia

Este proyecto está licenciado bajo la licencia Apache 2.0. Consulta LICENCIA para los términos completos.