Payment Gateway Questions & Answers

To properly tag UPI collections for capital market investments, a POS system needs to integrate with investment platforms via APIs, dynamically generate QR codes with transaction metadata, and use specific purpose codes designated by regulators like the Reserve Bank of India (RBI) and the National Payments Corporation of India (NPCI). A robust audit trail is essential for compliance and reconciliation.

First off, think of UPI receipts like micro-settlements inside a bigger insurance payment. Since high-value premiums may need multiple UPI transactions (because of per-transaction caps), your reconciliation software has to treat each payment leg separately but still tie them to one parent invoice or policy.
Here’s what needs updating:

• Multi-RRN Posting Logic

Each UPI leg (RRN) should post as an independent line in your receipts ledger but with a shared parent reference like an invoice_id or policy_no. So instead of 1 payment = 1 receipt, it becomes 1 invoice = N receipts. This ensures your journal entries stay balanced even when a premium is split across multiple UPI handles.

• Dynamic Payment Type Mapping

Your accounting engine needs to tag these entries with the correct NPCI purpose code (e.g., INS_PRM) so auditors can clearly see it’s a high-value insurance premium and not a regular UPI payment. This helps during both internal reconciliation and IRDAI compliance checks.

• Settlement File Matching Rules

Update the PSP settlement parser to group transactions by both invoice ID and merchant category code (MCC). Insurance UPI settlements might arrive as multiple small credits on different timestamps your system should aggregate them into one settled record once all RRNs are received.

• Midnight-Crossing Settlements

If any UPI leg gets settled after midnight, your D+1 reports should still map it to the original business date (when the policy was sold). So, add logic that matches on txn_date instead of just settlement_date for insurance payments.

• Customer Advance Handling

For partial payments (say, ₹8L premium paid in two ₹4L legs but only one clears), temporarily book the cleared amount to Customer Advance instead of marking the full invoice as paid. Once all legs clear, move it to Final Settlement.

• Reversal & Refund Journals

If a UPI leg fails or is reversed, auto-create a corresponding Reversal Journal Entry that negates the specific RRN amount not the entire invoice. This ensures your books don’t overstate revenue or collections.

• GST Linkage

When exporting to GST e-invoices, pick the latest successful UPI RRN as the Payment Reference ID in your JSON or PDF output. If multiple exist, include them all under the Payment Details block so GSTN reconciliation doesn’t choke on missing identifiers.

• Exception Handling

Create a reconciliation rule for Partially Settled High-Value UPI Receipts&;so your finance team gets an alert when one or more RRNs haven’t settled after 24 hours.

So, to make audits painless and stay compliant with NPCI + RBI rules, your billing software needs to tag every UPI collection for capital market investments with the correct purpose code before sending the payment request to your PSP or bank. This code tells the UPI network what kind of transaction it is (insurance, education, mutual fund, etc.), which directly affects how much you can collect and what reporting rules apply.

Here’s how to do it right:

Get NPCI’s Official Purpose Code List
NPCI assigns codes like CAP_MKT_INV for capital market investments, INS_PRM for insurance premiums, etc. You can find this in your PSP’s UPI integration docs (e.g., Razorpay, Cashfree, Paytm for Business). Make sure your billing app uses CAP_MKT_INV wherever applicable this is what lets the transaction qualify for higher UPI limits.

Map It to Your Product or Invoice Type
When your billing software generates a UPI intent or QR, it should check what kind of invoice it’s tied to.

If the invoice is tagged as a mutual fund top-up, SIP, or brokerage payment, automatically attach the CAP_MKT_INV purpose code.

If it’s for a retail or service product, use the default OTHERS or the correct business category code.

Include Purpose Code in Payment Payload
When creating a UPI collect request (upi://pay intent or PSP API call), include a metadata field for the purpose code. For most PSPs, that’s something like:

{
txnType: COLLECT,
purposeCode: CAP_MKT_INV,
amount: 250000.00,
payerVPA: user@upi,
merchantCategoryCode: 6211
}

This ensures that both NPCI and your acquirer bank recognize the transaction as a capital market payment.

Store It in Your Internal Ledger
Save the purpose code in your payments table like purpose_code: CAP_MKT_INV. This helps your reconciliation system and auditors later confirm that high-value transactions were processed under the right category.

Show It in Reports and Audit Logs
Add a column in your daily settlement reports and dashboards for Purpose Code. That way, finance and compliance teams can easily filter out capital market transactions and verify that all such receipts comply with the higher limit rules.

Validate Before Payment Submission
Add a quick pre-check in your billing flow if an invoice tagged as Capital Market Investment doesn’t have CAP_MKT_INV attached, block the payment initiation. It’s easier to stop errors upfront than fix audit mismatches later.

Include in GST E-Invoice or Reconciliation Data
When exporting your e-invoice or reconciliation JSON, embed the purpose code in an Additional Payment Info or UPI Details section. It makes GST and audit verification 10x faster.

• Pull the Correct Purpose Code from NPCI’s List

NPCI assigns purpose codes like INS_PRM (Insurance Premium Payment) or insurer-specific ones depending on the PSP you integrate with (like Razorpay, Paytm, or Pine Labs). Your invoicing tool should have a lookup table that maps each invoice type or merchant category to the right NPCI code. So, if the customer is paying an insurance invoice, your system automatically attaches INS_PRM to the UPI collect request.

• Add Purpose Code at the UPI Intent Level

When generating the UPI request (QR, intent, or collect), make sure you include the purpose code in the metadata field supported by your PSP API. For example, if you’re using /upi/pay or /upi/collect, pass the purpose code in a parameter like purpose or txnNote (depending on PSP spec). This ensures the code flows through to the NPCI backend and settlement reports.

• Store It in Your Internal Ledger

Don’t just rely on the PSP logs;record the same purpose code in your ledger or payments table along with the transaction ID, RRN, and invoice number. This helps you quickly reconcile transactions by purpose when auditors ask, Show me all UPI receipts tagged as insurance for FY 2025–26.

• Mirror the Code in GST E-Invoices

If your invoicing tool also generates GST-compliant invoices, you can include the purpose code in the payment metadata section of the e-invoice or PDF. This makes your accounting trail airtight;auditors love when the invoice, payment record, and PSP report all show the same purpose tag.

• Validate Purpose Code During Payment Initiation

Before creating the UPI request, add a quick validation step that checks if the customer’s invoice category matches an active NPCI purpose code. If it doesn’t, your app should block the payment and show a message like:

This payment type isn’t supported over UPI. Please use netbanking or RTGS.
That prevents miscoded transactions from being flagged later.

• Pass It Through to Settlement Reports

When your PSP sends back daily settlement files, match them with your purpose code records. If any settlement comes back without the INS_PRM tag, flag it for manual review. Sometimes PSPs drop metadata during bulk settlements, so having your own tag helps you verify purpose-level compliance.

• Automate Reporting for Audits

Create a simple monthly or quarterly report grouped by purpose code, total count, amount collected, refunds, and reversals. That way, when regulators or insurers ask for all UPI insurance transactions, you can export it in seconds.

• Handle Mixed-Invoice Scenarios Carefully

If a customer pays multiple invoice types (say insurance + add-on service) in one UPI payment, don’t bundle them under a single purpose. Either split the payment internally or tag it as the dominant purpose (insurance) while noting the breakdown in your ledger.

• Sync Purpose Codes Across Systems

If your invoicing tool integrates with an ERP (like SAP, Tally, or Zoho Books), make sure the same purpose code field exists in both. That keeps your accounting and payment systems consistent for audits.

• Stay Updated with NPCI Circulars

Purpose codes sometimes get updated or expanded by NPCI and RBI. Add a cron job or internal admin panel to update your mapping table quarterly so you’re always compliant.

So yeah, after the new NPCI rules, insurance premiums can go way above the old ₹1L cap, but that introduces edge cases split payments, partial refunds, and time-based reversals that can break your reconciliation logic if not tested properly. Here’s how you can QA it thoroughly:

• Simulate High-Value Payments (Within and Above Limits)

Start with test payments just under, at, and over the per-transaction and daily caps (say ₹2L, ₹5L, ₹10L). Make sure the system correctly records which payments succeeded, split, or failed. Your reconciliation module should identify partial success and map each split leg to the right invoice.

• Trigger Partial Refunds

For an ₹8L insurance payment split across two ₹4L UPI transactions, test refunding ₹4L or ₹2L to check if the system correctly links the refund RRN to the right original transaction. The ledger should show both the debit (payment) and credit (refund) tied under the same invoice.

• Test Full Reversals on Failed Settlements

Simulate cases where UPI settlement fails for one split leg. NPCI will issue an auto-reversal your reconciliation tool must match that reversal entry with the correct UPI Txn ID and mark it settled – reversed instead of leaving it open.

• Validate Date Boundary Cases

Some UPI settlements cross midnight due to bank batching. Test refunds that are processed the next day but belong to a previous-day collection, and make sure your D+1 reconciliation report still ties them to the correct invoice date.

• Chargeback Handling

Create chargeback events where the payer disputes a transaction. Check if your software can import or match the PSP-provided chargeback reference number and auto-adjust the receivable in your insurance ledger.

• Audit Trail Validation

Every refund or reversal should keep a full trail original Txn ID, RRN, refund ID, timestamp, and reference invoice. QA should confirm the reconciliation report shows a clear chain of events for compliance and IRDAI audit readiness.

• Settlement Report Cross-Check

Compare PSP settlement files vs. internal journal entries. The totals for each day should match even when multiple refunds or reversals happen on split transactions.

• Prioritize Netbanking for High-Value Premiums

When the UPI limit is reached or a transaction exceeds the per-transaction cap, your first fallback should be netbanking (NEFT/RTGS/IMPS). Most banks allow higher transaction ceilings (₹10–₹50 lakh depending on account type), and it’s already familiar to insurance customers.
Your checkout should detect the UPI decline reason code (like limit exceeded) and instantly show a Pay via Netbanking option with the invoice amount pre-filled.

• Offer Card Payments (if Policy Type Allows)

Some insurers still accept credit/debit cards for policy renewals and top-ups. If your tool supports card processing, show a Pay via Card fallback option right after UPI fails. Bonus: card payments are great for users who want instant confirmation and rewards, but check if your insurer’s backend can handle the MDR fees (some don’t).

• Enable EMI or Auto-Debit Mandates

For customers paying large annual premiums, enable them to set up eNACH mandates or UPI AutoPay so future renewals stay within daily caps. Your fallback screen can say something like:

This payment exceeds UPI’s daily limit. Would you like to set up monthly AutoPay instead?
That turns a failure moment into a subscription opportunity.

• Add Wallet or Account Balance Options

If your platform supports stored balance (like a customer wallet or linked corporate account), allow them to top up via UPI first (within limits), then pay the full insurance premium using the balance. This two-step approach helps keep UPI usage compliant while still completing large transactions.

• Suggest Bank Transfer Instructions (Manual Mode)

When all else fails, automatically generate a Bank Transfer option display your insurer’s or aggregator’s virtual account number (VAN) or static IFSC details along with the invoice ID as reference.
Then, once they upload the UTR, your tool can mark the invoice as Pending Verification. It’s not sexy, but it works for high-value corporate clients.

• Enable Split Payment Workflow

If your invoicing tool supports it, offer to automatically split the invoice into smaller UPI-friendly chunks. Show a quick modal saying:

Your payment will be processed in 2 transactions of ₹5,00,000 and ₹3,00,000.
That keeps the user experience smooth while staying within NPCI limits.

• Real-Time Alerts & UI Prompts

Add logic to detect UPI limit breaches early. When the customer enters the amount, show a friendly warning:

UPI supports up to ₹10,00,000 for verified insurance payments. You can use netbanking or RTGS for higher amounts.
Proactive messaging saves you from failed payments and angry support calls.

• Smart Defaulting Based on Customer Profile

If your tool knows a customer typically pays large premiums (say above ₹5 lakh), default to showing netbanking or card first instead of UPI. This kind of predictive fallback helps reduce transaction failures before they happen.

• API-Level Fallbacks

On the backend, implement logic that catches NPCI or PSP limit error codes (U17, TLE, etc.) and automatically retries using the next available payment method configured in the customer’s preferences.

• Notify Finance & Support Teams

Every time a UPI transaction fails due to cap limits, send a webhook or alert to your finance/support channel (Slack or email). They can then follow up with the customer, send alternate payment links, or manually extend invoice due dates if needed

If your ERP handles UPI payments for capital market investments, tagging the right purpose code is super important — not just for compliance but also for making audits painless later. NPCI and your bank partners require that every UPI collection carry a purpose or merchant category tag (like INSURANCE_PREMIUM, CAPITAL_MARKET_INVESTMENT, etc.) so they can classify transactions properly during settlement and reporting.
Here’s a simple way to get this right:

• Add a purpose code field in your UPI transaction schema.

When the ERP creates a UPI collect request (/upi/collect or similar), include a key like purpose_code or txnPurpose in the payload. For capital market flows, this should map to NPCI’s defined code — usually something like CAPITAL_MARKET_INVESTMENT or CAPMKT_INV.
Example:
{
txn_id: INV12345,
amount: 250000,
payer_vpa: user@upi,
purpose_code: CAPMKT_INV,
remarks: Equity Purchase via Broker XYZ
}

• Use metadata rules to auto-tag transactions.

Don’t rely on manual tagging. Have your ERP detect when the ledger account, invoice type, or customer category = brokerage, mutual fund, or demat account funding, and then automatically assign the correct purpose code.
For example, any payment linked to GL accounts like Capital Market Receivables or Broker Margin Deposits should auto-inherit CAPMKT_INV.

• Validate purpose codes before posting.

Your ERP should block any UPI request that doesn’t have a valid code this ensures you never send untagged payments that cause reconciliation pain later.

• Store the code for audits.

When the UPI payment settles, store the purpose_code in your transaction and ledger tables so your auditors can filter by it during quarterly reviews. It’ll make your compliance reporting way cleaner.

• Sync with your payment gateway or PSP’s mapping.

Some gateways (like Razorpay or Cashfree) already have NPCI purpose code enums baked in. Make sure your ERP’s code names match theirs otherwise the tag may not pass through to the UPI network.

• Optional: include the code in the GST e-invoice or reconciliation exports.

Add a field like UPI Purpose in your audit or invoice exports. When auditors check high-value inflows, they can immediately see whether it was a capital market transaction no manual tracing needed.

So, the trick is to make your accounting package aware of the merchant category and new NPCI UPI rules. Since NPCI now allows higher daily caps (like up to ₹10 lakh/day) for specific categories such as insurance, mutual funds, and hospitals, your system should be able to detect when a transaction falls into one of those privileged categories and tell the customer right away.

Here’s a simple way to do it:

Tag every UPI transaction with an NPCI purpose code For insurance, use the correct MCC or purposeCode (like INSURANCE_PREMIUM or similar). When your app calls the UPI intent or PSP API, this tag is what helps banks determine the applicable limit.

Query the PSP or your UPI gateway for limit eligibility Most UPI PSPs (like Razorpay, Cashfree, or Pine Labs) expose APIs or webhooks that return limit-related metadata. You can call this before initiating payment. If the API returns enhanced limit available, your app can surface a message like:

Good news! Your insurance premium payment qualifies for higher UPI limits under NPCI’s updated rules.

Show dynamic UI messages based on eligibility When the system detects that the customer is paying an insurance premium and the amount is within the enhanced limit, show a contextual banner or tooltip during checkout or payment confirmation.

Cache the info for repeat users Once you confirm a customer’s VPA (Virtual Payment Address) and category eligibility, cache it for a session so you’re not pinging the PSP every time.

Fail gracefully if not eligible If the transaction doesn’t qualify or limits are exceeded, the message should switch to something like:

This payment exceeds your UPI limit for today. Try using NetBanking or eNACH instead.

• Add a Pre-Check Before Payment Initiation

Before you hit the UPI API, your checkout or billing engine should check the policy amount against the merchant’s category-wise cap (e.g., ₹5 lakh or ₹10 lakh). If it’s higher, trigger a split payment workflow instead of failing the transaction outright. This is your first line of defense.

• Smart Auto-Split Logic

Your system should automatically break the total insurance premium into chunks that stay within NPCI’s per-transaction limit but still add up to the total due.
For example, if the cap is ₹5 lakh and the premium is ₹8 lakh, your system should queue two transactions: one for ₹5 lakh and one for ₹3 lakh. Keep a parent-child relationship between these splits in your ledger so reconciliation stays clean later.

• User Confirmation Flow

You don’t want to surprise users with multiple UPI notifications.
Show a confirmation screen that says something like:

Your payment will be processed in 2 secure UPI transactions due to the new NPCI limit.
That helps avoid confusion when they see multiple debit messages.

• Sequential vs. Parallel Triggers

You can go two ways:

Sequential: Wait for each payment confirmation before initiating the next one (safer, but slower).

Parallel: Trigger multiple requests at once if your PSP supports batching (faster, but needs careful handling of partial successes).
Most insurance platforms prefer sequential for compliance reasons, it ensures no double debit if one chunk fails.

• Ledger Mapping for Splits

Each split should post as a separate line item in your sub-ledger with a shared parent transaction ID.
Example:

Parent: Policy #123, Total ₹8,00,000

Child 1: ₹5,00,000 (UPI Ref 001)

Child 2: ₹3,00,000 (UPI Ref 002)
This makes refunds, reversals, and audits much easier to manage later.

• Retry & Rollback Rules

If one of the split payments fails, you need a rule to either retry that portion or auto-refund the completed chunks whichever is safer.
For example, if payment #1 succeeded but #2 failed, reverse the first payment and mark the transaction incomplete. Don’t settle partial insurance premiums unless your business rules explicitly allow it.

• Settlement Reconciliation

Since each split generates a separate UTR (Unique Transaction Reference), your reconciliation script needs to combine them back under one logical premium collection.
Make sure you record both the total collected and number of splits in your daily settlement report that’ll make your finance team’s life way easier.

• Compliance Metadata

Tag all split payments with a consistent “purpose code” for insurance premiums (like INS_PRM) and a shared batch or policy reference. This ensures that during audits or NPCI reviews, the entire chain is traceable as one policy payment.

• PSP Behavior Testing

Different PSPs handle high-value UPI transactions differently (some throttle or delay them). Test across PSPs to make sure auto-splits don’t trigger anti-fraud limits or timeout errors.

• Alerts for Partial Success

Set up an alert to notify your finance team if any split payment succeeds but others fail. This lets them quickly follow up with the customer or reinitiate the missing portion manually.

So yeah, after the new UPI limits kicked in, the main thing finance teams need to watch is how much of the daily cap each merchant or sub-account is actually consuming. Billing systems should send alerts before the cap is hit, not after. Here’s what you’d want to set up:

• Threshold Alerts (75%, 90%, 100%)

Set automated alerts that trigger when aggregate UPI usage for the Capital Markets category crosses 75%, 90%, and 100% of the allowed limit. For example, if the cap is ₹10L/day, get a Slack or email ping when usage hits ₹7.5L, ₹9L, and ₹10L. This gives you time to route payments or delay non-critical debits.

• Category-Level Monitoring

Don’t lump all UPI payments together tag each transaction with NPCI’s purpose code (CAP_MKT_INV) so you can track capital market payments separately from retail or insurance. The alert system should summarize per-category totals in real time.

• Per-Handle Aggregation

Since one business might use multiple UPI handles (like different VPAs for different schemes), your alert logic should roll up totals across all handles under one PAN or merchant ID. Otherwise, you’ll miss the bigger picture and accidentally exceed limits.

• Bank/PSP-Specific Alerts

Some banks throttle UPI volumes during peak hours. Create a secondary alert if one particular PSP handle (say HDFC or Axis) starts rejecting transactions due to rate or volume limits. This helps you failover to alternate bank rails faster.

• Real-Time Dashboard for Finance Teams

Build a small UPI Limit Usage dashboard showing:

• Total UPI inflow for the day
• Remaining headroom (₹ left before hitting the cap)
• Breakdown by handle, product, and transaction type

You can automate this with a cron job that runs every 15–30 minutes and updates your internal finance portal.

• Over-Cap Attempt Logging

Log every failed or blocked UPI payment that was declined due to limit exceeded or txn amount too high. Those entries help in identifying recurring patterns (like one broker or product hitting the cap too early every day).

• Daily Summary Report

At the end of the day, send an auto-generated email to finance leads summarizing total UPI collection, number of high-value transactions, over-limit attempts, and remaining headroom. This helps for audit and compliance tracking