Limits
Read this before you build on it. Everything here is a real residual case, most of them have a one-click fix in your dashboard, and one of them can cost you goods.
The one that costs money
Section titled “The one that costs money”A false confirmation means you shipped for free. No system that infers which order a payment was for can make that impossible, and this one does not claim to. It is why every confirmation carries an evidence label — so you can decide what is strong enough for what value of goods, rather than treating all four the same.
There are also no chargebacks and no dispute process. There is no mechanism for one, because no intermediary is holding the money. What reached your account is in your account, and undoing it is between you and your customer.
Residual ambiguity
Section titled “Residual ambiguity”A late payer whose amount has since been reserved and tapped by somebody else produces a credit that could belong to either order. We park it rather than guess. The rest rule — a lapsed amount is passed over for an hour by default while any other free amount exists — makes this need a payment more than an hour late at a busy price point, but it does not make it impossible. Rest is tenant-configurable up to two hours and never shorter than an hour; see Reservation timing.
You get: a payment.ambiguous webhook and a row in Unplaced payments with
both candidate orders. One click.
Payment links need an online merchant UPI ID
Section titled “Payment links need an online merchant UPI ID”A UPI payment link — upi_uri or an entry in app_links, which is what the web
SDK’s pay(app) and the iOS and Android SDKs open — is declined by the
customer’s UPI app unless your UPI ID is an online merchant ID from a payment
gateway. NPCI’s rules block
a payment link to a person, which is what a personal UPI ID is, and one to an
offline merchant that is not verified (UPI Consolidated Circular v1.0, 18
September 2026, §7.9; the rule has applied since 1 April 2024). The free
business IDs from PhonePe Business, Google Pay for Business, Paytm Business
and bank QR apps are offline merchants. PhonePe shows “Your payment is
declined for security reasons.”
So the hosted pay page has no app buttons and pays by QR. On a phone, for an order up to ₹2,000, the customer shares the QR to their UPI app — the button names Google Pay on Android and PhonePe on iPhone, the apps shown to pay a shared QR there — or saves it, taps Scan in their UPI app and picks it from the gallery. PhonePe on Android opens a contact picker for a shared QR, never a payment, so a PhonePe customer there saves it and uploads it from Scan. On a desktop they scan it with their phone. Each way, the amount fills in by itself.
Shared and saved QR payments stop at ₹2,000
Section titled “Shared and saved QR payments stop at ₹2,000”UPI apps refuse a payment from a shared or saved QR image above ₹2,000. That is NPCI’s cap on P2P “QR share and pay” (OC-76, restated in OC-76C). Google Pay allows ₹2,000.00 and refuses ₹2,001 before the PIN. So for an order over ₹2,000 the pay page offers no share or save on a phone. The customer copies your UPI ID and types the amount, or scans the QR with another phone. Typing the amount is the copy path below, which is where wrong amounts come from.
Copy-the-UPI-ID rounding
Section titled “Copy-the-UPI-ID rounding”The pay page always shows your UPI ID and the exact amount, each with a copy button, and over ₹2,000 that is how a customer on one phone pays. Some customers type the amount by hand, and some of them round it — ₹498.99 becomes ₹499. That amount matches no reservation, but the order that reserved ₹498.99 is still a candidate: it existed in the 24 hours before the credit and its amount is within ₹1.
This is the single largest source of parked credits.
You get: a payment.unplaced webhook with that order as a candidate, and
delta_paise recorded when you place it. Show the “pay this exact amount”
warning next to the copy fallback; it is the cheapest prevention there is. The
hosted page’s Copy amount copies the exact number — 498.99, or 499 for
a whole-rupee amount — with no ₹ sign.
The same person, twice, quickly
Section titled “The same person, twice, quickly”If the same UPI handle pays the same amount within 30 minutes, the second credit is parked as a duplicate. That is right far more often than it is wrong — accidental double payments are common — but a genuine repeat purchase at the same price inside half an hour gets caught by it too.
You get: payment.duplicate with the candidate order listed. One click.
iOS gets no receipt
Section titled “iOS gets no receipt”Android apps can read the UTR back from the UPI app and confirm on the bank’s own reference number, independent of the amount — but only when they pay through a link, which needs an online merchant UPI ID (above). iOS grants an app nothing back. iOS payments confirm on the amount like everyone else’s. This is a platform limit and no future version fixes it.
Band exhaustion
Section titled “Band exhaustion”If every amount from your list price down to the bottom of your discount band
is reserved at once, reserve returns 503 pool_exhausted rather than handing
out an amount that cannot be told apart from another order.
Widening the band is not the fix — it buys capacity by giving away more money per order. If your volume is genuinely past what a 99-paise band holds, the fix is a merchant VPA from your own bank, whose channel returns your order reference directly and removes amount variation completely. Money still never touches us. That feed is not built yet.
Rate limits
Section titled “Rate limits”Every public endpoint is rate limited. Wherever you already hold an identity —
a tenant, a page token, or a device — the limit is keyed on it and not on IP
address, so one office behind a NAT is never throttled as if it were an
attacker. The few doors that open before you have an identity (pairing a
device, signing a phone in, asking for a sign-in link) have nothing to key on
but where the request came from, and the table says which those are. A 429
carries {"error":"rate_limited","retry_after_seconds":60} and a retry-after
header telling you how long to wait.
| what it limits | ceiling | keyed by |
|---|---|---|
the pay page (/p/{token}/*) |
60/60s | the page token |
the rest of the API (POST /v1/intents, .../reserve, and the rest of /v1/*) |
120/60s | your tenant |
requesting a sign-in link (POST /app/login and POST /v1/app/sessions/request) |
5/60s per source, 5/60s per address, plus 30/60s in aggregate | the source (an IPv4 address, or an IPv6 /64), then the address, then everyone |
pairing a device (POST /v1/devices/pair) |
10/60s per source, plus 60/60s in aggregate | the source, then everyone |
the reporter app (POST /v1/reports) and the iPhone Shortcut (POST /v1/reports/shortcut), one shared budget |
60/60s | your tenant and device together |
replaying a webhook delivery (.../replay) |
10/60s | your tenant |
A reusable product link (GET/POST /pr/{slug}) reuses the pay page’s and the
API’s own counters, keyed on the link’s slug instead.
Asking for a sign-in link also needs a bot check, and it runs before any of
those three counters. From a web page — the sign-in form, and the
/delete-account page — it is a Cloudflare Turnstile token. A
request without a valid one is refused (403, {"error":"turnstile_failed"} on
the JSON door) before it can use up the allowance of the address it names, and
no mail is sent. The Android and iOS apps are not asked for a token; they are
held to the same counters instead.
The iPhone Shortcut’s 429 is a sentence rather than JSON, like every reply
that endpoint sends, because the Shortcut shows it as a notification. It
carries the same retry-after header.
Signup and device pairing are the two actions an unauthenticated caller can take, so each carries a second, constant-keyed ceiling on top of its own per-address or per-source one — otherwise N addresses or N source IPs would each get their own budget, and our own domain would end up mailing, or a guesser probing, without limit. The aggregate ceiling caps that. Because Cloudflare’s counters are per data-centre, it is a strong bound, not a strict global guarantee.
Webhook delivery has a ceiling
Section titled “Webhook delivery has a ceiling”Order matching itself scales the way the reservation capacity table describes. Webhook delivery does not, and we would rather you knew the real number than a reassuring one.
On the Workers Free plan, one delivery attempt costs three subrequests — a
claim, the POST to your endpoint, and the write that records the result —
out of a 50-subrequest budget the five-minute sweep also spends on other
bookkeeping before it delivers anything at all. That works out to roughly
144 deliveries an hour, globally, across every tenant, every event type,
and every retry — not 144 per tenant.
At real volume this bites: 1,000 orders an hour with ordinary abandonment puts
intent.expired alone past 300 events an hour, and expiry events get no
inline first attempt, so all of it comes out of this same budget. Past roughly
480 orders an hour the queue grows faster than it drains.
Nothing is lost when this happens — an undelivered event waits its turn and stays visible and replayable in Settings → Developers — but it can wait. A Workers Paid plan raises the subrequest budget from 50 to 10,000 and this ceiling rises with it. This is a stated ceiling, not a solved problem.
Email latency is unmeasured
Section titled “Email latency is unmeasured”We have no figure for how long your bank takes to send a credit alert email, or how long Gmail takes to forward it. We will not quote one we have not measured.
What we do instead: a credit that reaches us more than 30 minutes after the
bank’s own timestamp is parked as stale rather than matched, and one with no
usable timestamp is parked too. We never fall back to the time we happened to
receive something. The reporter app removes the question
for anyone who installs the version from moneylanded.com, which reads the bank’s
SMS on the phone — on a live credit, 160 ms from SMS to server. The Google Play
build has no SMS feed.
No order binding, which is the root of all of it
Section titled “No order binding, which is the root of all of it”Everything above is engineering around one fact: the order reference the payer
sets never reaches the payee. A payment gateway’s webhook carries your
order_id directly and this entire correlation layer disappears. It costs
about 2% in platform fees. MDR — 0.4% on payments above ₹2,000 from 15
October 2026 — is charged by the acquiring bank on the P2M leg, so a merchant
collecting on a merchant VPA pays it with or without a gateway; what this
service removes is the platform fee, never the MDR.
That is the trade. We think it is a good one for a lot of sellers. It is not a good one for everybody and we would rather you knew which you were.
One bank
Section titled “One bank”HDFC only. The parser is built for more — keyed on the sending domain, one module and one test corpus per bank — but only HDFC has one today.
Where parked credits go
Section titled “Where parked credits go”Nowhere, until you look at them. Parked credits are never dropped and never turned into an error. Your account receives money that has nothing to do with orders, and the right behaviour is to ignore all of it while leaving a trail.
A credit with an order it could plausibly be for — one that existed in the 24
hours before it, within ₹1 — shows up in GET /v1/credits, in Unplaced
payments, and behind a webhook and a notification, with the reason and the
candidates, until you place it on an order or dismiss it as not one.
Dismissing keeps the row for audit.
The rest — money nothing we know of could be for — is kept quietly instead: no
webhook, no notification, no operator alert. It is still stored: under Other
payments in Unplaced, and in GET /v1/credits?quiet=include (or quiet=only),
in case we are wrong and you want to place it on an order yourself. Other
payments shows the newest 50; GET /v1/credits?quiet=only returns the rest.
Every failure has a definite end
Section titled “Every failure has a definite end”| what happens | what we do |
|---|---|
| the same credit arrives twice, or on both feeds | nothing. The bank’s reference number is the primary key. |
| a customer pays twice | duplicate, with the candidate order. |
| a payment lands after its reservation lapsed | confirms that order, evidence late — or parks, if your policy says so. |
| a late payment where the amount was reused and both orders tapped | ambiguous, both listed. |
| a credit that is not for an order at all | kept quietly under Other payments: no webhook, no notification. |
| a forwarded mail delayed past 30 minutes, or with no date | stale. Quiet too, the same way, when no order is within ₹1. |
| a message we cannot parse | our operators are alerted. The body is never stored. |
| every amount in the band is held | 503 with a retry-after. |
| you send requests faster than a limit allows | 429 with retry-after; nothing you sent takes effect. |
| a forged email | rejected at the DKIM check. Nothing stored. |
| a revoked or unknown device token | 401. Nothing stored. |
| your webhook endpoint is down | six attempts, then it waits in Settings for you to replay it. |
| your feed goes silent | our operators are alerted when an account makes reservations and sees no credits at all. |
Nothing guesses.