Pinelabs MCP Server

O servidor Pine Labs Online MCP implementa o Model Context Protocol (MCP) para permitir integração perfeita entre as APIs de pagamento online da Pine Labs e ferramentas de IA. Ele permite que assistentes de IA realizem operações da API Online da Pine Labs, capacitando desenvolvedores a criar aplicações de pagamento inteligentes e orientadas por IA com facilidade.

GitHub

Experimente este MCPPatrocinado

Documentação

Pine Labs Payment Gateway MCP Server (Oficial)

Cliente MCP para o gateway de pagamento Pine Labs — conecte Claude Desktop, Cursor, VS Code e outros assistentes de IA às APIs de pagamento Pine Labs usando suas credenciais de cliente.

Documentação Completa | Ferramentas Disponíveis | Casos de Uso | Perguntas Frequentes

Pré-requisitos

Node.js 18+ — Baixar ou instalar via npm i pinelabs-mcp
Credenciais de Cliente Pine Labs — Obtenha seu Client ID e Client Secret no portal do desenvolvedor Pine Labs

Início Rápido

Obtendo Suas Credenciais

Cadastre-se ou faça login no painel do comerciante Pine Labs fornecido com sua conta.
Navegue até as configurações da sua conta para localizar seu Client ID e Client Secret.
Use essas credenciais na configuração do servidor MCP conforme mostrado nas instruções de configuração acima.

Configurar e 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

Em seguida, reinicie seu cliente de IA e comece a usar as ferramentas 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 Suportados

Cliente	Comando	Caminho de Configuração
Claude Desktop	`setup claude-desktop`	Config do Claude específica da plataforma
Cursor	`setup cursor`	`~/.cursor/mcp.json`
VS Code	`setup vscode`	`.vscode/mcp.json` (projeto)
Windsurf	`setup windsurf`	`~/.codeium/windsurf/mcp_config.json`
OpenCode	`setup opencode`	`.opencode/config.json` (projeto)
GitHub Copilot	`setup copilot`	`~/.copilot/mcp-config.json`
OpenAI Codex	`setup codex`	`.codex/config.toml`

Configuração Manual

Se preferir configurar manualmente em vez de usar npx pinelabs-mcp setup, adicione o seguinte à configuração MCP do seu cliente de IA:

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

Observação: O VS Code usa "servers" em vez de "mcpServers" como chave de nível superior. Para ambiente de produção, adicione "PINELABS_ENV": "prod" ao bloco env.

Ferramentas Disponíveis

O Servidor MCP Pine Labs expõe mais de 50 ferramentas em várias categorias. Cada ferramenta mapeia para um endpoint específico da API de pagamento Pine Labs.

Legenda de Tipos de Ferramentas

Cada ferramenta abaixo é marcada com um Tipo indicando seu padrão de acesso e risco operacional. Isso ajuda você a entender quais ferramentas são seguras em implantações somente leitura e quais exigem confirmação explícita do usuário em fluxos autônomos (agênticos).

Tipo	Significado	Exemplos
Leitura	Seguro, sem efeitos colaterais. Apenas busca ou consulta dados. Permitido em modo somente leitura.	`get_order_by_order_id`, `get_all_settlements`, `list_plural_apis`
Escrita	Cria ou modifica recursos. Não destrutivo, mas altera o estado do servidor. Ignorado em modo somente leitura.	`create_payment_link`, `create_order`, `update_plan`
Destrutivo	Cancela, exclui, reembolsa ou movimenta dinheiro. Irreversível ou com impacto financeiro. Deve exigir confirmação explícita do usuário em fluxos de agente.	`cancel_order`, `create_refund`, `create_payout`, `delete_plan`

Modo somente leitura: Execute o servidor com --read-only (ou defina a configuração equivalente) para registrar apenas as ferramentas Read e ignorar todos os conjuntos de ferramentas Write / Destructive. Útil para análises, monitoramento ou contextos de agente não confiáveis.

Links de Pagamento

Ferramenta	Tipo	Descrição	Referência da API
`create_payment_link`	Escrita	Criar um novo link de pagamento para coletar pagamentos	Link de Pagamento - Criar
`get_payment_link_by_id`	Leitura	Buscar um link de pagamento pelo ID do link de pagamento	Link de Pagamento - Obter por ID
`get_payment_link_by_merchant_reference`	Leitura	Buscar um link de pagamento pela referência do link de pagamento do comerciante	Link de Pagamento - Obter por Referência
`cancel_payment_link`	Destrutivo	Cancelar um link de pagamento ativo	Link de Pagamento - Cancelar
`resend_payment_link_notification`	Escrita	Reenviar uma notificação de link de pagamento ao cliente	Link de Pagamento - Reenviar

Pedidos

Ferramenta	Tipo	Descrição	Referência da API
`get_order_by_order_id`	Leitura	Recuperar detalhes do pedido pelo ID do pedido	Pedido - Obter por ID
`get_order_by_merchant_order_reference`	Leitura	Recuperar detalhes do pedido pela referência do pedido do comerciante	Pedido - Obter por Referência do Comerciante
`capture_order`	Escrita	Capturar um pagamento previamente autorizado contra um pedido	Pedido - Capturar
`cancel_order`	Destrutivo	Cancelar um pagamento pré-autorizado contra um pedido	Pedido - Cancelar
`fetch_order_payments`	Leitura	Buscar todas as tentativas de pagamento associadas a um pedido	Pedido - Obter Pagamentos

Pedidos de Checkout

Ferramenta	Tipo	Descrição	Referência da API
`create_order`	Escrita	Criar um novo pedido de checkout e gerar um link de checkout	Pedido - Criar

Pagamentos com Cartão

Ferramenta	Tipo	Descrição	Referência da API
`create_card_payment`	Escrita	Criar um pagamento com cartão servidor a servidor contra um pedido	Pagamento com Cartão - Criar
`get_card_details`	Leitura	Recuperar detalhes do cartão (BIN, rede, tipo) para um número de cartão	Detalhes do Cartão - Obter

OTP

Ferramenta	Tipo	Descrição	Referência da API
`generate_otp`	Escrita	Gerar um OTP para um fluxo de autenticação de pagamento com cartão	OTP - Gerar
`submit_otp`	Escrita	Enviar um OTP para concluir uma autenticação de pagamento com cartão	OTP - Enviar
`resend_otp`	Escrita	Reenviar um OTP para uma autenticação de pagamento com cartão	OTP - Reenviar

Reembolsos

Ferramenta	Tipo	Descrição	Referência da API
`create_refund`	Destrutivo	Iniciar um reembolso total ou parcial contra um pagamento capturado	Reembolso - Criar

Liquidações

Ferramenta	Tipo	Descrição	Referência da API
`get_all_settlements`	Leitura	Recuperar todas as liquidações do comerciante dentro de um intervalo de datas	Liquidações - Obter Todas
`get_settlement_by_utr`	Leitura	Recuperar uma liquidação específica pelo seu UTR (Referência Única de Transação)	Liquidação - Obter por UTR

Pagamentos (Payouts)

Ferramenta	Tipo	Descrição	Referência da API
`create_payout`	Destrutivo	Criar um pagamento (payout) para distribuir fundos a um beneficiário (movimenta dinheiro)	Payout - Criar
`get_payout_details`	Leitura	Recuperar detalhes de um payout pelo ID do payout	Payout - Obter
`get_payout_payments`	Leitura	Listar pagamentos associados a um payout	Payout - Obter Pagamentos
`get_payout_balance`	Leitura	Recuperar o saldo de payout disponível para o comerciante	Payout - Obter Saldo
`update_payout`	Escrita	Atualizar uma solicitação de payout existente	Payout - Atualizar
`cancel_payout`	Destrutivo	Cancelar uma solicitação de payout pendente	Payout - Cancelar

Assinaturas

Ferramenta	Tipo	Descrição	Referência da API
`create_plan`	Escrita	Criar um novo plano de assinatura	Plano - Criar
`get_plans`	Leitura	Recuperar planos de assinatura	Plano - Obter Todos
`get_plan_by_id`	Leitura	Recuperar um plano de assinatura pelo ID do plano	Plano - Obter Específico
`get_plan_by_merchant_reference`	Leitura	Recuperar um plano pela referência do plano do comerciante	Plano - Obter Específico
`update_plan`	Escrita	Atualizar um plano de assinatura existente	Plano - Atualizar
`delete_plan`	Destrutivo	Excluir um plano de assinatura	Plano - Excluir
`create_subscription`	Escrita	Criar uma nova assinatura contra um plano	Assinatura - Criar
`get_subscriptions`	Leitura	Recuperar assinaturas	Assinatura - Obter Todas
`get_subscription_by_id`	Leitura	Recuperar uma assinatura pelo ID da assinatura	Assinatura - Obter Específica
`get_subscription_by_merchant_reference`	Leitura	Recuperar uma assinatura pela referência do comerciante	Assinatura - Obter Específica
`pause_subscription`	Escrita	Pausar uma assinatura ativa	Assinatura - Pausar
`resume_subscription`	Escrita	Retomar uma assinatura pausada	Assinatura - Retomar
`cancel_subscription`	Destrutivo	Cancelar uma assinatura ativa	Assinatura - Cancelar
`update_subscription`	Escrita	Atualizar uma assinatura existente	Assinatura - Atualizar
`create_presentation`	Escrita	Criar uma apresentação (solicitação de pagamento) para uma assinatura	Apresentação - Criar
`get_presentation`	Leitura	Recuperar uma apresentação pelo ID da apresentação	Apresentação - Obter
`delete_presentation`	Destrutivo	Excluir uma apresentação	Apresentação - Excluir
`get_presentations_by_subscription_id`	Leitura	Recuperar todas as apresentações de uma assinatura	Apresentação - Obter por Assinatura
`get_presentation_by_merchant_reference`	Leitura	Recuperar uma apresentação pela referência do comerciante	Apresentação - Obter
`send_subscription_notification`	Escrita	Enviar uma notificação de pré-débito para uma assinatura	Apresentação - Criar
`create_debit`	Destrutivo	Executar um débito (cobrança de pagamento) contra uma assinatura	Apresentação - Criar
`create_merchant_retry`	Escrita	Tentar novamente a execução de mandato para um débito com falha (máx. 3 tentativas)	Nova Tentativa do Comerciante

Pagamentos UPI

Ferramenta	Tipo	Descrição	Referência da API
`create_upi_intent_payment_with_qr`	Escrita	Criar um pagamento UPI por intenção com código QR para cobrança instantânea	UPI Intent QR

Relatórios e Busca de Transações

Ferramenta	Tipo	Descrição	Referência da API
`get_payment_link_details`	Leitura	Buscar detalhes de links de pagamento dentro de um intervalo de datas	Documentação da API
`get_order_details`	Leitura	Buscar detalhes de pedidos dentro de um intervalo de datas	Documentação da API
`get_refund_order_details`	Leitura	Buscar detalhes de pedidos de reembolso dentro de um intervalo de datas	Documentação da API
`search_transaction`	Leitura	Buscar uma transação pelo ID da transação	Documentação da API

Ferramentas de Desenvolvedor

Ferramenta	Tipo	Descrição
`get_api_documentation`	Leitura	Buscar documentação da API Pine Labs para uma API específica
`list_plural_apis`	Leitura	Listar todas as APIs Pine Labs (Plural) disponíveis com descrições
`detect_stack`	Leitura	Detectar a pilha de tecnologia do projeto atual para personalizar a orientação de integração
`integrate_pinelabs_checkout`	Leitura	Gerar trechos de código e orientação de integração conscientes da pilha para o Pine Labs Checkout

Análises do Comerciante

Ferramenta	Tipo	Descrição
`get_merchant_success_rate`	Leitura	Buscar a taxa de sucesso de transações do comerciante em um intervalo de datas

Casos de Uso

Integração com Gateway de Pagamento: Conecte seu aplicativo de IA ao gateway de pagamento da Pine Labs para criar pedidos de checkout, gerar links de pagamento e processar transações programaticamente.
Fluxos de Checkout com IA: Crie experiências de checkout conversacionais onde assistentes de IA criam pedidos, geram links de pagamento e acompanham o status do pagamento em tempo real.
Automação de Pagamentos UPI: Gere códigos QR de intenção UPI e processe pagamentos UPI por meio de interfaces orientadas por IA para cobrança no aplicativo ou no ponto de venda.
Gerenciamento do Ciclo de Vida de Assinaturas: Automatize a criação de planos de pagamento recorrentes, ativação de assinaturas, ciclos de pausa/retomada, apresentações de débito e notificações pré-débito.
Fluxos de Pagamento Agênticos: Crie agentes de IA autônomos que gerenciam operações de pagamento de ponta a ponta — desde a criação do pedido até a conciliação — sem intervenção manual.
Rastreamento e Conciliação de Pedidos: Consulte detalhes de pedidos, pesquise transações por ID e concilie pagamentos para verificar status e resolver disputas.
Análise e Relatórios de Pagamentos: Recupere relatórios de links de pagamento, resumos de pedidos, detalhes de reembolsos e taxas de sucesso do comerciante em intervalos de datas personalizados.
Automação de Suporte ao Cliente: Permita que agentes de suporte ou chatbots consultem transações, verifiquem status de pagamentos, cancelem pedidos e reenviem notificações de pagamento.

Servidor MCP Remoto

O Servidor MCP Remoto é hospedado e mantido pela Pine Labs. Use esta abordagem se preferir configurar seu cliente de IA manualmente com o endpoint remoto em vez de usar a CLI npm.

Benefícios

Zero Configuração: Sem Python, Docker ou infraestrutura local para gerenciar
Sempre Atualizado: Atualizações automáticas com os recursos mais recentes da API de pagamento e patches de segurança
Alta Disponibilidade: Hospedado na infraestrutura de produção da Pine Labs
Autenticação Segura: Autenticação de credenciais do cliente via HTTPS

Se você estiver se conectando a uma implantação remota auto-hospedada em vez do serviço hospedado pela Pine Labs, substitua a URL remota abaixo por <your-mcp-server-url>.

Pré-requisitos

npx é necessário para fazer proxy da conexão MCP remota. Instale o Node.js (que inclui npm e npx):

macOS

brew install node

Windows

choco install nodejs

Alternativamente, baixe de https://nodejs.org/.

Verificar Instalação

npx --version

Uso com Cursor

Adicione o seguinte às configurações MCP do seu 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>"
      ]
    }
  }
}

Substitua <your-client-id> e <your-client-secret> pelas suas credenciais da Pine Labs. Consulte Autenticação para detalhes.

Uso com Claude Desktop

Adicione o seguinte ao seu 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>"
      ]
    }
  }
}

Substitua <your-client-id> e <your-client-secret> pelas suas credenciais da Pine Labs.

Configure servidores MCP no Claude Desktop: Guia de Início Rápido MCP
Instale o Claude Desktop: Download

Uso com VS Code

Adicione o seguinte às configurações do seu 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}"
        ]
      }
    }
  }
}

Saiba mais sobre servidores MCP na documentação do modo agente do VS Code.

Autenticação

O servidor MCP autentica usando credenciais de Client ID e Client Secret emitidas pela Pine Labs.

Nota: Para implantações locais, as credenciais podem ser passadas via argumentos de CLI ou variáveis de ambiente. Para o servidor remoto, as credenciais são passadas como cabeçalhos HTTP.

Servidor MCP Local

Implante o servidor MCP na sua própria infraestrutura para controle total do ambiente de execução.

Pré-requisitos

Python 3.12+
Docker (opcional, para implantação em contêiner)
Git

Instalar no Windows (Chocolatey)

A maneira mais rápida de obter o servidor MCP em uma máquina Windows é via Chocolatey. O pacote é um wrapper fino que instala Python 3.10+ como dependência e depois instala pinelabs-mcp-server do PyPI, registrando um shim pinelabs-mcp em PATH.

choco install pinelabs-mcp

Verifique a instalação:

pinelabs-mcp --help

Execute o servidor via stdio:

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

Configuração do cliente MCP (Claude Desktop / Cursor / VS Code)

Após choco install, aponte seu cliente MCP para o shim 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

Usando Imagem Docker Pública (Recomendado)

Use a imagem Docker oficial da Pine Labs diretamente. Nenhuma etapa de build é necessária.

Nota: Para fixar uma versão específica, substitua pinelabs/mcp:latest por pinelabs/mcp:<version-tag> (por exemplo, pinelabs/mcp:v1.0.0) nas configurações abaixo.

Uso com Claude Desktop

Adicione o seguinte ao seu 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"
      }
    }
  }
}

Substitua <your-client-id> e <your-client-secret> pelas suas credenciais da Pine Labs.

Configure servidores MCP no Claude Desktop: Guia de Início Rápido MCP
Instale o Claude Desktop: Download

Uso com VS Code

Adicione o seguinte às configurações do seu 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}"
        }
      }
    }
  }
}

Saiba mais sobre servidores MCP na documentação do modo agente do VS Code.

Uso com 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>"
      }
    }
  }
}

Substitua <your-client-id> e <your-client-secret> pelas suas credenciais da Pine Labs.

Build a partir do Docker (Alternativa)

Clone o repositório e crie a imagem Docker localmente:

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

Após a criação, substitua pinelabs/mcp:latest por pinelabs-mcp-server:latest nas configurações acima.

Build a partir do Código Fonte

Execute o servidor diretamente do código fonte sem 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

Após a execução, configure seu cliente MCP para conectar ao processo local. Exemplo 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"
        }
      }
    }
  }
}

Configuração

Variáveis de Ambiente

Variável	Obrigatória	Padrão	Descrição
`PINELABS_CLIENT_ID`	Sim	--	Client ID da Pine Labs para autenticação na API
`PINELABS_CLIENT_SECRET`	Sim	--	Client secret da Pine Labs para autenticação na API
`PINELABS_ENV`	Não	`uat`	Ambiente de destino: `uat` ou `prod`
`LOG_LEVEL`	Não	`INFO`	Nível de verbosidade do log: `DEBUG`, `INFO`, `WARNING`, `ERROR`
`LOG_FILE`	Não	stderr	Caminho para o arquivo de saída de log
`READ_ONLY`	Não	`false`	Restringir a ferramentas somente leitura (desativa operações de escrita)
`TOOLSETS`	Não	all	Lista separada por vírgulas de conjuntos de ferramentas a habilitar

Flags de Linha de Comando

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)

Depuração do Servidor

Use a flag --log-level DEBUG e opcionalmente --log-file para gravar logs detalhados para solução de problemas:

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

FAQ

P: Preciso fornecer valores em paisa? R: Não. Os valores são especificados em rúpias (por exemplo, 500 para INR 500). Nenhuma conversão para paisa é necessária.

P: Quais ambientes são suportados? R: O servidor suporta os ambientes uat (padrão) e prod. Defina via PINELABS_ENV ou --env.

P: Posso restringir quais ferramentas estão disponíveis? R: Sim. Use a flag --read-only para desativar operações de escrita, ou use --toolsets para habilitar conjuntos de ferramentas específicos (por exemplo, --toolsets payment_links,orders).

P: Onde posso encontrar a referência completa da API? R: Visite a Documentação para Desenvolvedores da Pine Labs para a referência completa da API.

Palavras-chave

Pine Labs, Pine Labs Online, Plural, Plural Online, gateway de pagamento, gateway de pagamento online, gateway de checkout, checkout de pagamento, checkout online, checkout hospedado, página de pagamento, pagamentos, pagamentos online, pagamentos digitais, processamento de pagamentos, aceitar pagamentos, coletar pagamentos, integração de pagamentos, integração de gateway, API de pagamentos, API de pagamento, API de checkout, API de gateway, UPI, cartões, cartão de crédito, cartão de débito, internet banking, carteira, EMI, EMI sem cartão, assinaturas, pagamentos recorrentes, pedidos, pagamentos de pedidos, criar pagamento, iniciar pagamento, processar pagamento, links de pagamento, servidor MCP, Model Context Protocol, automação de pagamentos com IA, pagamentos agênticos, pagamentos por código QR, orquestração de pagamentos, API do comerciante, relatórios de transações, fintech, SDK

Licença

Este projeto é licenciado sob a licença Apache 2.0. Consulte LICENSE para os termos completos.