Payment Gateway Questions & Answers

Assuming your ERP finance module includes payment of credit cards bills using UPI, then you really should have warning signals that will ensure your finance department is mindful of daily limits and any possible compliance concerns, as now NPCI has per transaction limits and daily limits. Being without them, you stand a chance of failed payments, audit problems, or spontaneous refusals.

The following is the list of alerts to be turned on:

Aggregate Alert of UPI Usage in a Day.

• What it entails: It follows credit card bill payments to merchants and/or customers, aggregate of total UPI inflows.
• Trigger: E.g. when daily total exceeds, e.g., 80-90 percent of NPCI daily cap of that category.
• Why: Have your finance team go ahead before the daily limit is violated, and they will not have to fall in mid-day.
• Example message:
• Credit card payments UPI inflow per day have hit 8.2L (82/10L daily limit). Think of making high value payments to Net Banking.

Over-Limit Attempt Alert

• What it does: Records any UPI transactions that have failed because they have gone over per-transaction or daily limits.
• Trigger: Response code limitexceeded or txndeclined.
• Why: Aids in predicting the level of demand of increased caps as well as identifying users on limits.

Purpose Code Mismatch Alert

• What it does: Marks any transactions in which the UPI purpose code does not correspond to Credit Card Bill Payment.
• Reason: To settle and comply appropriately; mis-tagged payments may lead to audit problems.

Delayed Settlement Alert

• How it works: Monitors transaction that is awaiting settlement outside a specific period (e.g. 2-3 hours).
• Reason: To identify caught payments at an early stage to avoid reconciliation issues.

Refund/Charge back Spike Alert.

• What it does: Checks whether the volume of refunds and reversals is greater than some percentage (e.g. more than 5% of the daily volume).
• Reason: Notification: Funds to an abnormal performance, possible user conflict or incompatibility.

PSP Failure rate Notifier.

• What it does: Tracks failures by handle of PSP/bank.
• Trigger: 3/4th of the total transactions in a short period.
• Why: Helps redirects the payments after using other PSPs prior to users encountering unsuccessful UPI transactions.

Billing software can inform customers of higher UPI limits for credit card bill payments by integrating with card issuers and payment gateways to access transaction-specific limit data. It can then use triggered, real-time notifications to message the customer at the point of payment.

In September 2025, the National Payments Corporation of India (NPCI) raised the UPI per-transaction limit for capital market investments to ₹5 lakh, with a daily cap of ₹10 lakh. Since these limits can still be exceeded for large investments, a subscription billing engine needs workflows to manage high-value payments. An auto-split feature is not supported natively by UPI, but can be simulated using a series of separate, sequential transactions.

So the trick is to use NPCI’s category-level UPI metadata and your payment gateway’s API responses to guide customers before they hit a limit. When your invoicing app knows that the invoice is tagged under capital markets (or whatever category NPCI lists as eligible for higher UPI caps, up to ₹10 lakh/day), it can show real-time contextual messages like:

This payment qualifies for higher UPI limits under NPCI’s capital market category. Please use a verified UPI handle or bank that supports the ₹10L/day cap.

To make that happen:

• Check the merchant category and UPI PSP eligibility before starting the payment. You can use NPCI’s category codes or the gateway’s merchant onboarding metadata to determine if the invoice falls under Capital Market Investments.
• Fetch customer UPI handle status using your payment provider’s eligibility API (some gateways expose whether a handle supports higher limits). If the handle is verified, flag that the higher limit applies.
• Inject real-time messaging in checkout UI: Your frontend should display a dynamic banner or tooltip based on that check.
• Handle post-API feedback too: If the UPI intent or collect request returns a limit-related response, surface a friendly fallback message right there, don’t just show Payment failed. Instead:
• Looks like your current UPI account can’t process this amount. Try another verified handle or split your payment.
• Cache the eligibility result for that user session, so you don’t hammer NPCI or the PSP with repeated checks.
• Optional: If your tool supports multiple currencies or geographies, localize these limit-related messages in the user’s preferred language so there’s zero confusion

If your POS system is handling credit card bill payments via UPI, you can’t just keep retrying failed requests blindly — NPCI APIs and PSPs can get overloaded, and aggressive retries risk duplicate charges, throttling, or failures. You need a smart retry/throttle workflow.

Use Exponential Backoff with Jitter

• Don’t retry at fixed intervals. Start with a small delay (e.g., 2–3 seconds), double it on each failed attempt (2 → 4 → 8 → 16s), and add random jitter ±1–2s.
• Cap the number of retries (usually 3–5 attempts) to avoid infinite loops.
• Why: This reduces the chance of multiple POS terminals hitting the API simultaneously during high load.

Monitor API Response Times

• Track average response times per PSP handle or bank.
• If response times exceed a threshold (e.g., 2–3s), temporarily slow down retries or queue them for a short delay.
• Tip: Keep this state in memory (Redis or local cache) to share across your POS instances.

Apply Per-Terminal/User Rate Limits

• Limit concurrent retries per POS terminal or user.
• Example: max 1 retry chain per user, max 50 retries per terminal per minute.
• Why: Prevents system-wide retry storms.

Respect PSP/UPI Error Codes

• If the API returns a retry-after or limit_exceeded code, honor it instead of retrying immediately.
• This keeps you compliant with PSP/UPI guidelines and avoids further declines.

Circuit Breaker for Persistent Failures

• If API failures persist above a threshold (e.g., 20% failed attempts over 3 minutes), open a circuit breaker: stop retries temporarily for that PSP or terminal.
• Test with a single request before resuming normal retry flow (half-open state).

Logging & Alerting

• Log every retry attempt with: Txn ID, timestamp, retry count, and error type.
• Trigger alerts if retry volume spikes unusually — ops can then reroute traffic to alternate PSPs.

Start by connecting your payment layer (whatever orchestrates UPI requests, Pine Labs, Razorpay, Cashfree, etc.) to an NPCI or PSP metadata API. These APIs can tell you whether a payer–merchant combo is eligible for the updated cap (like ₹5L or ₹10L for specific categories such as credit card bills). The moment a customer enters their UPI ID or selects a bank handle, run a quick check:

If category = Credit Card Bill Payment and payer_verified = true → mark as eligible for higher UPI limits.

Once that check passes, show a short informational banner or tooltip right in the payment screen — something like:

Good news! Your UPI handle supports the new higher limit for credit card bill payments (up to ₹10L/day).

You can make it dynamic, too, if a user’s UPI handle doesn’t qualify, show:

This UPI ID supports payments up to ₹1L. For higher payments, please try NetBanking or another UPI ID linked to your verified account.

If you’re processing split transactions (because a user tried to pay more than the per-transaction cap), display a short confirmation like:

Your payment will be auto-split into two UPI requests to stay within NPCI’s per-transaction limit.

On the backend, store the eligibility status and any NPCI or PSP response codes in your transaction logs. That helps support teams explain payment outcomes later and it’s gold for debugging edge cases during rollout.

Make your invoicing tool smart enough to notice when someone’s trying to pay more than the UPI limit, quietly break it into smaller transactions, and handle them one by one in the background. Then stitch it all together so your books still show a single payment. It’s mostly about saving the customer from Payment Failed – Limit Exceeded errors and your finance team from reconciliation nightmares.

So, after the September 2025 UPI rule change, credit card bill payments can have higher daily caps but still have a per-transaction cap meaning a single large bill might need to be split into multiple UPI transactions. If your reconciliation software doesn’t support this auto-split workflow, your downstream ledgers and settlement files are going to look messy real fast.

Here’s how you should design those workflows:

• Add a pre-reconciliation validation layer:

When your system ingests transaction data, it should check whether any single bill payment exceeds the UPI per-transaction cap (say ₹2 lakh). If yes, automatically flag it as a split-required transaction and queue it for sub-transaction generation.

• Auto-split logic with parent-child mapping:

The software should create multiple child transactions, each within the cap (e.g., a ₹4 lakh bill splits into two ₹2 lakh UPI transactions). Each child transaction should carry the same parent ID and reference the same payer details for unified tracking.

• Assign sequence and settlement references:

Add a split sequence number and link all parts under a single Parent Settlement ID. This helps during reconciliation when settlement confirmations come back separately from the PSP or bank.

• Update reconciliation matching rules:

During matching, your software needs to sum all child transactions belonging to a parent and match the combined total against the source invoice or card bill. That way, you don’t show false partial match errors in reports.

• Add audit tagging for split payments:

Every child transaction should retain the same purpose code (P1003 for credit card bills) but should also include a split index field (1/2, 2/2, etc.) for audit and traceability.

• Handle reversals cleanly:

If one of the split payments fails or reverses, your reconciliation system should automatically flag the parent as partially settled and initiate retry workflows only for the failed portion not the entire amount.

• Integrate user and finance alerts:

Build alerts like Bill partially settled ₹2 lakh pending due to per-transaction cap so finance teams know whether to trigger retries or alternative payment routes like NEFT.

If your POS system accepts UPI payments for term deposit openings, you’ll need to tweak both your settlement and ledger rules to handle the new high-value UPI limits properly. Since September 15, 2025, the NPCI lets verified categories like term deposits go up to ₹10 lakh per day — but that also means your system has to treat these transactions differently from normal retail payments.
First, update your settlement rules. Tag every UPI transaction meant for term deposits with the correct NPCI purpose code INVS_TD. This ensures they aren’t mixed with normal sales payments. Route them through a separate investment or deposit settlement batch rather than the standard POS batch, because banks may process these through different merchant codes and timings. Large-value UPI payments (above ₹2 lakh) often settle on a T+1 basis, so your settlement logic must support delayed posting. Also, only allow routing through verified PSP handles that actually support high-value UPI; not every PSP does. Finally, your reconciliation flow should match each incoming UPI receipt against a term deposit creation request so that the finance team never sees unlinked receipts in their end-of-day reports.
Next, update your ledger mapping. In normal retail flows, a UPI receipt credits sales revenue but for term deposits, that’s incorrect. Instead, when a customer opens a term deposit via UPI, the entry should debit the bank (UPI receipts) and credit a Term Deposit Liability account. Once the term deposit is actually created or confirmed in the core banking system, that liability should move to the Term Deposit Principal account. If a refund happens before creation, you’d reverse it by debiting the liability and crediting Bank UPI Refunds Payable.
You’ll also want to add some extra controls in your posting logic. Always store the NPCI purpose code (INVS_TD) in your transaction records so audits can identify investment-linked UPI flows. Maintain a link between the UPI Reference ID and the Term Deposit ID to make reconciliation painless. Set up a daily aggregate view to make sure the total UPI receipts tagged as INVS_TD don’t exceed ₹10 lakh per merchant per day. And log PSP handle details and payer VPAs to meet compliance requirements.
Before settlement posting, the POS should also verify a few things: that the PSP handle supports high-value UPI, the transaction status is successful, the settlement window hasn’t expired, and the total daily inflows for that category are still within limit. If any of these checks fail, the transaction should be flagged for manual review instead of getting auto-posted.

With updated regulations in India, UPI payments for capital market investments have a per-transaction limit of ₹5 lakh and a daily cumulative limit of ₹10 lakh as of September 2025. To handle investment payments exceeding these limits, an accounting package should add specific workflows that automate the splitting, sequencing, and reconciliation of these transactions.