Collect any way people pay. Settle it instantly. Keep it safe.
That's the whole of what GroPay does. Real-time UPI collections and payouts across India today, on infrastructure built from day one to carry the same instant, secure settlement model to every payment mode we add next.
Built for India first. Built to go further.
We didn't start with a generic global gateway and bolt India on afterward — we started with UPI, the rail that actually moves money for most of the country, and we're building outward from there.
India: UPI, done properly
Real-time collections and payouts on the rail your customers already trust — no app they need to install, no card they need to enter.
- UPI Intent — one-tap deep link into the payer's UPI app
- UPI Collect / QR — scan-and-pay on the same hosted page
- Bank payouts via IMPS/NEFT/RTGS straight from your payout wallet
- Multi-provider routing underneath — one integration, no single point of failure
Global: beyond one country's rails
India is the foundation, not the ceiling. The same routing engine that picks a UPI provider today is built to add new rails without a rewrite — that's the whole point of building it this way.
- Crypto on/off-ramps for cross-border settlement
- Additional local rails as we expand market by market
- One dashboard, one API contract, regardless of which rail settles the transaction
What we're building next.
A payments platform is only as good as the rails it can reach. Here's what we're actively building toward, in the open — so you know what to expect and when to check back.
Crypto on/off-ramps
Letting a merchant collect and settle in crypto alongside UPI, through the exact same API contract — no separate integration, no separate dashboard.
Cross-border settlement
Extending the wallet + ledger model that already powers domestic payouts to multi-currency balances, for merchants who sell beyond India.
More rails per market
UPI came first because it's how India pays. Each new market gets the rail that actually fits it — not a one-size-fits-all card form bolted on everywhere.
Integrate once. We handle the routing.
A redirection-based hosted checkout — never a raw handoff of customer bank credentials to your servers — with a webhook and a status API you can rely on either way.
Create a payment
Call our payin API with an amount and your own order reference. Idempotent by design — retries never double-charge.
Customer pays
They land on our hosted checkout page and pay by UPI Intent or Collect/QR — nothing to build on your end.
You get notified
An HMAC-signed webhook fires the moment the transaction settles, success or failure — with a public status API as backup.
Funds move
Successful payins credit your wallet; payouts debit it straight to a bank account via our payout API.
Built generally enough to fit specifically.
One payin/payout contract, applied to however your business actually collects and pays out.
E-commerce & marketplaces
Checkout payins plus scheduled payouts to sellers, from one wallet model.
Subscriptions & SaaS
Recurring collections with idempotent retries, so a network blip never double-charges a customer.
Gaming & digital goods
High-frequency small-ticket payins on a rail with no per-transaction app install.
Lending & fintech
Ledgered wallets and configurable per-client limits for platforms that need a real audit trail.
Travel & ticketing
Time-sensitive payins with a hosted status page payers can trust mid-checkout.
Cross-border commerce
India today, more rails as our global roadmap lands — same integration throughout.
A payments API that reads like documentation, not a spec.
- One contract for payin and payout — same field names, same idempotency model, same error shapes.
- Signed webhooks — HMAC-SHA256 over timestamp + body, so you can verify every delivery is really from us.
- A sandbox that behaves like production — isolated test data, same API, before you ever touch real money.
- Documented, not just built — full request/response docs and a live API console inside your dashboard.
// Create a payin POST https://api.gropay.in/payin X-Api-Key: <your_key> { "amount": 499, "orderId": "ORD-1029", "redirectUrl": "https://yourapp.com/thanks" } // 201 response { "transactionId": "gro7f3ka9d1e802", "paymentPageLink": "https://pay.gropay.in/...", "status": "INITIATED" }
Built like infrastructure, because that's what it is.
Every account is KYC-verified before it goes live, every transaction is logged against a real ledger, and nothing about our own uptime should ever be the reason a payment fails.
KYC-gated onboarding
No account goes live without verification — every client on the platform has been checked, not just signed up.
Ledgered wallets
Every credit and debit is a ledger entry, not just a balance update — a full, auditable trail for every rupee that moves.
Fail-open rate limiting
Generous per-client limits, and if our own limiter ever has a hiccup, requests still go through — an infra blip on our side should never fail your payment.
Automated daily reconciliation
A signed CSV export lands on your SFTP every day, filtered by what actually changed — built for finance teams who need to close the books.
Configurable, per client
Transaction limits, daily caps, and commission rates are all set per account — not one-size-fits-all defaults.
A dashboard finance teams can use
Live transaction search, generated reports, wallet visibility, and API-key management — without a support ticket.
Idempotent by design
Every payin and payout is keyed on your own order reference — a retried request returns the original result, never a duplicate charge.
Redirection, never a raw handoff
Payer credentials are entered on our hosted page, not passed through your servers — a deliberate choice, not a shortcut.
Multi-provider routing
A rule engine picks the provider for every transaction — no single upstream outage takes your payments down with it.
A few things people usually ask.
Do I need a card network integration to accept UPI?
No — UPI Intent and Collect/QR are handled entirely on our hosted checkout page. You call one API to create the payment and receive a link; we handle the rest.
How do I know a webhook actually came from GroPay?
Every delivery is signed HMAC-SHA256 over the timestamp and raw body. You verify it with your signing secret before trusting the payload — the exact method is in the docs.
Can I test before going live?
Yes — every new account is provisioned with an isolated sandbox behind the same API and dashboard, so you can build and test against realistic data before touching real money.
What happens if I retry a payment request by accident?
Nothing bad — requests are idempotent on your own order reference. A retried create-payin call returns the original transaction rather than creating a second one.
When are the crypto and cross-border rails coming?
They're actively in development — see the Roadmap section above. We'd rather ship them properly than announce a date we can't hold to; reach out if you want early access when they're ready.
How do I reconcile transactions against my own books?
A signed CSV lands on your SFTP server daily, filtered to whatever actually changed — built specifically so finance teams don't have to reconcile by hand.