Pine Labs Agent Skills

Build Pine Labs payment integrations faster with AI coding assistants.

Pine Labs Agent Skills add product-specific payment knowledge to your AI coding environment. The installed skills help your assistant understand Pine Labs APIs, payment flows, security requirements, and implementation best practices while you write or review integration code.

Instead of generating generic payment code, your coding assistant can use Pine Labs-specific implementation guidance for checkout, orders, webhooks, refunds, payouts, subscriptions, and other payment workflows.

Why use Pine Labs Agent Skills?

Generic AI assistants know how to write code, but they don't know Pine Labs-specific implementation rules. Without product context, assistants produce code that compiles but may:

Skip callback signature verification
Mix UAT and production endpoints
Expose credentials in frontend code
Retry financial operations without idempotency
Treat browser redirects as final payment confirmation

Agent Skills give the assistant the judgment layer it needs to avoid these common integration mistakes.

Get started

Install Pine Labs Agent Skills into your project with a single command:

Bash

npx pinelabs-agent-skills-cli add skills

The CLI prompts for which assistant frameworks to configure, writes skill files into the project, and updates framework manifests.

For non-interactive setup:

Bash

npx pinelabs-agent-skills-cli add skills --frameworks claude-code --yes

Install Agent Skills →

Supported AI coding assistants

Agent Skills support nine AI coding assistants:

Claude Code — Anthropic
Cursor — AI-first editor
VS Code Copilot — GitHub
Gemini CLI — Google
Kiro — AWS
OpenCode — Open source
GitHub Copilot CLI — GitHub
Codex CLI — OpenAI
Antigravity — AI assistant

What Agent Skills add to your AI assistant

API and integration guidance

Identify the relevant Pine Labs API and implementation pattern for your task.

Security-first implementation

Apply secure patterns for credentials, callbacks, tokens, payment data, and sensitive information.

Sandbox-first development

Use UAT for development and testing before moving an integration to production.

Payment operation safety

Apply idempotency patterns for money-moving operations and avoid unsafe retry behaviour.

Production readiness

Review integrations for common go-live issues, including environment configuration, callback verification, credential exposure, and payment confirmation.

What's included?

The installation adds Pine Labs payment skills to your project.

Structure

pinelabs-skills/
├── SKILL.md                                      <- Root router, global safety rules, and integration flow
├── .pinelabs-skills-version.json                 <- Version marker for doctor/update stale-install detection
├── validation-and-testing.md                     <- UAT, negative testing, webhook, refund, and release evidence checklist
├── validation-and-testing/                       <- Focused checkout, refund, webhook, SDK, subscription, and settlement test guides
│   ├── checkout-orders.md                         <- Idempotency, timeout, duplicate, callback, and final-state tests
│   ├── refunds.md                                 <- Full/partial refund, timeout, duplicate, and reconciliation tests
│   ├── webhooks.md                                <- Signature, replay, duplicate, and ordering tests
│   ├── mobile-web-sdks.md                         <- Callback, cancellation, interruption, and recovery tests
│   ├── subscriptions.md                           <- Plan, presentation, retry, and lifecycle tests
│   └── settlements.md                             <- Payout, split-release, UTR, and delayed-settlement tests
├── go-live.md                                    <- Production readiness gates and rollout checklist
├── webhooks.md                                   <- Raw-body, signature verification, replay, and idempotency guidance
├── common-mistakes.md                            <- Review checklist for unsafe or brittle integration patterns
├── upgrade-advisor.md                            <- Update flow for current, stale, and legacy installed skills
├── upgrade-advisor/                              <- Installer and integration upgrade routes with source-verified release checks
│   ├── installer.md                               <- Version marker, managed manifest, and catalog update workflow
│   └── integration.md                             <- SDK/API/OpenAPI upgrade, regression, and rollback workflow
├── migration-guides/                             <- Provider migration routing and concept maps
│   ├── README.md                                 <- Migration guide router
│   ├── razorpay-reference.md                      <- Credentials, lifecycle, webhook, refund, and reconciliation mapping
│   └── *.md                                      <- Provider-specific migration workflows
├── evals/                                        <- Workflow evaluation prompts for safe assistant routing
│   ├── validation-and-testing.evals.json          <- Duplicate, replay, pending callback, and refund-timeout prompts
│   ├── common-mistakes.evals.json                 <- Credential and frontend-fulfillment prompts
│   ├── migration-razorpay.evals.json              <- Legacy-order routing and rollback prompt
│   └── upgrade-advisor.evals.json                 <- Source-verified SDK upgrade prompt
├── getting-started/                              <- Domain folder for onboarding and auth
│   ├── README.md                                 <- Domain router for setup and environment basics
│   ├── authentication.md                         <- OAuth token generation and credential handling
│   ├── dashboard-signup-and-token.md             <- Dashboard signup, API key setup, and first token guidance
│   └── references/REFERENCE.md                   <- Index for getting-started skill files
├── payments/                                           <- Payment gateway domain folder
│   ├── README.md                                 <- Domain router for payment gateway scenarios
│   ├── orders.md                                 <- Order creation, fetch, capture, cancel lifecycle
│   ├── checkout.md                               <- Hosted checkout and redirect flow guidance
│   ├── card-payments.md                          <- Card payment APIs including auth/capture flow
│   ├── upi-payments.md                           <- UPI collect/intent/QR payment implementations
│   ├── netbanking.md                             <- Net banking payment option integration
│   ├── wallet.md                                 <- Wallet payment option integration
│   ├── payment-links.md                          <- Payment link creation and lifecycle actions
│   ├── payment-option.md                         <- Payment option eligibility and UPI VPA lookup
│   ├── customers.md                              <- Customer profile create/fetch/update workflows
│   ├── tokenization.md                           <- Card/network token create/fetch/delete workflows
│   ├── convenience-fee.md                        <- Convenience fee calculation flows
│   ├── pay-by-points.md                          <- Reward points eligibility and redemption
│   ├── affordability-suite.md                    <- EMI/offer discovery and affordability checks
│   ├── bnpl.md                                   <- BNPL payment journey and controls
│   ├── apple-pay.md                              <- Apple Pay payment authorization flow
│   ├── brand-wallet.md                           <- Brand wallet lifecycle and balance operations
│   ├── brand-wallet-payments.md                  <- Wallet-funded payments and load-money flows
│   ├── international-payments.md                 <- Cross-border payments and conversion support
│   ├── e-challans.md                             <- E-challan create/retrieve/download flows
│   ├── upi-reserve-pay.md                        <- Fund-blocking and reserve-pay workflows
│   ├── mobile-sdks/                              <- Native mobile SDK guidance group
│   │   ├── README.md                             <- Router: asks Android/iOS/Flutter when platform is unspecified
│   │   ├── android.md                            <- Android native SDK integration guidance
│   │   ├── ios.md                                <- iOS native SDK integration guidance
│   │   └── flutter.md                            <- Flutter native SDK integration guidance
│   ├── web-sdks/                                 <- WebView/browser SDK guidance group
│   │   ├── README.md                             <- Router: asks Android/iOS/Flutter/React Native when unspecified
│   │   ├── android.md                            <- Android web SDK integration guidance
│   │   ├── ios.md                                <- iOS web SDK integration guidance
│   │   ├── flutter.md                            <- Flutter web SDK integration guidance
│   │   ├── react-native.md                       <- React Native web SDK integration guidance
│   │   └── faqs.md                               <- Web SDK troubleshooting and FAQs
│   └── references/REFERENCE.md                   <- Index for payments skill files
├── settlements/                                  <- Settlements and fund movement domain folder
│   ├── README.md                                 <- Domain router for refunds/payouts/settlements
│   ├── refunds.md                                <- Refund initiation and status handling
│   ├── payouts.md                                <- Payout balance, bulk, and scheduled operations
│   ├── settlements.md                            <- Settlement fetch and reconciliation guidance
│   ├── split-settlements.md                      <- Multi-party settlement release/cancel flows
│   └── references/REFERENCE.md                   <- Index for settlement skill files
├── subscriptions/                                <- Recurring payments domain folder
│   ├── README.md                                 <- Domain router for recurring billing
│   ├── subscriptions-plans.md                    <- Plan creation and management
│   ├── subscriptions-subscriptions.md            <- Subscription lifecycle APIs (create/pause/resume/cancel)
│   ├── subscriptions-presentations.md            <- Debit presentation and retry operations
│   └── references/REFERENCE.md                   <- Index for subscriptions skill files
└── p3p/                                          <- P3P x402 and UPI ReservePay domain folder
    ├── README.md                                 <- Domain router for P3P pay and SDK integration
    ├── pay.md                                    <- CLI-driven mandate, PPT token, and debit guidance
    ├── sdk-integration.md                        <- x402 SDK integration guidance for apps
    ├── references/                               <- CLI and SDK reference files plus domain index
    ├── templates/                                <- Next.js, Express, Python, and vanilla client templates
    └── evals/p3p-pay.evals.json                  <- P3P pay skill evaluation cases

The package includes:

Best-practices skill — security, routing, UAT, idempotency, and production guidance
API-area reference skills — payment-specific guidance for APIs and workflows
P3P skills — x402/UPI ReservePay guidance for agent payments and SDK integration
Workflow guides — validation checklists, go-live gates, migration guides, and upgrade paths

The assistant starts with the best-practices guidance and loads the relevant API reference based on your task.

Explore available skills →

Security defaults

Pine Labs Agent Skills apply security-first guidance to help developers build and review payment integrations safely.

Follow secure payment practices

Use UAT for development and testing
Build and validate integrations against the UAT environment before moving to production.
Keep credentials server-side
Store PINELABS_CLIENT_ID and PINELABS_CLIENT_SECRET in a secure server-side environment. Never expose secrets in frontend code or client-side bundles.
Verify callback signatures
Always verify callback or webhook signatures before processing payment events or updating transaction status.
Use idempotency for money-moving operations
Use idempotency keys for operations such as payments, refunds, and other financial transactions to prevent unintended duplicate processing.
Protect sensitive data
Never log secrets, access tokens, card data, or sensitive PII. Review application and debugging logs before sharing or storing them.
Confirm production actions
Require explicit confirmation before executing production payment operations or making changes that can affect live transactions.
No telemetry
The installer does not collect telemetry. It only writes local skill files and managed manifest blocks in the project path you choose.

How Agent Skills differ from MCP Server

	Agent Skills	MCP Server
What it provides	Product knowledge and implementation guidance	Live tool access to Pine Labs APIs
How it works	Local skill files in your project	Hosted server with natural language execution
Best for	Writing and reviewing integration code	Querying, testing, and executing APIs directly

They are complementary. Agent Skills tell the assistant how to do Pine Labs work correctly. MCP Server lets the assistant do Pine Labs work directly.

For most developers, Agent Skills are the better starting point — you need guidance before you need live tool access.

Package details

Property	Value
npm package	`pinelabs-agent-skills-cli`
Binary	`pinelabs-agent-skills`
Node.js	18 or newer
License	MIT
Unpacked size	~722 kB

Resources

Integration Guide

Install Pine Labs Agent Skills with a single command and configure any of the eight supported AI coding assistants.

Use Cases

Explore how Pine Labs product context helps with checkout, callbacks, refunds, payouts, and production readiness.

npm Package

Package details, install metadata, and version history on npm.