Guides

Failed stablecoin pay-ins: underpaid, late or on the wrong network

What a platform should do when a stablecoin pay-in fails, arrives short or over, lands late, comes from an unexpected payer or uses the wrong network.

Caio Barbosa

Founder & CO-CEO

Forbes Under 30. One of the leading voices in Fintech & Crypto in Brazil. Writes weekly about stablecoins, payments, and the future of financial infrastructure in Latin America.

Cover image for Lumx blog article: Failed stablecoin pay-ins: underpaid, late or on the wrong network
Cover image for Lumx blog article: Failed stablecoin pay-ins: underpaid, late or on the wrong network

A failed stablecoin pay-in is a collection that did not end as one clean credit: the payer sent less or more than the invoice, paid after the window closed, paid from an account nobody expected, left out the reference, or sent a stablecoin on a network the receiver did not ask for. Each case needs a policy written before the first payer makes the mistake, because support cannot invent one live.

This guide is for the team that owns the collection flow inside a platform: what to decide for each exception, what the provider does on its side, and what the ledger should record. If a single payer is asking where their money went, start with deposit held or returned, which is the troubleshooting page for that question.

How does a stablecoin pay-in fail?

A pay-in has two halves. The payer moves money on a local rail or on a blockchain, and the provider matches it to an instruction, converts it and credits the customer. Most failures happen at the seam between the two: the money arrived, but it does not fit the instruction it was meant for.

The seven exceptions, where each one starts and who can fix it.

Exception

Where it starts

Who can fix it

Underpaid against the invoice

The payer chose the amount

Your product: ask for a top-up or accept a partial

Overpaid against the invoice

The payer chose the amount

Your product: credit the extra or refund it

Paid after the window closed

The payer was slow

The provider returns it; you issue a new collection

Paid without the reference

The payer's bank form

The provider may still credit the account; your ledger has to place it

Paid by an unexpected sender

A third party paid for the customer

Compliance decides; it can end in a hold or a return

Below the minimum or above the limit

The amount itself

The provider does not convert it; operations resolves it

Stablecoin sent on the wrong network

The payer's wallet

Often nobody quickly; prevention is the only good fix

The first two are commercial decisions. The next three are matching problems. The last two are hard stops that no retry will fix.

Here is one example of each, with what the Lumx docs, read on November 17, 2026, say happens.

One example per exception, and the Lumx behavior the docs describe.

Exception

Example

What happens on Lumx

Underpaid

An invoice for R$10,000 is paid to the customer's static Pix code with R$9,500

The rule converts any deposit paid with its identifier, so R$9,500 converts at the market rate and the success event reports the smaller final amount

Overpaid

The same invoice is paid with R$10,500

All R$10,500 converts; sending back the extra R$500 is an off-ramp to a destination whose holder relationship is CUSTOMER, the type the docs reserve for refunds to a customer's clients

Late

A floating Pix on-ramp is created at 10:00 on a Monday and paid at 11:00 on Tuesday

Floating Pix and SPEI on-ramps expire after one day, so the deposit is not processed and is refunded to the original sender on the same rail

No reference

A US importer wires dollars for an on-ramp and leaves out the memo

The API reference marks the memo as required for the deposit to be matched to that on-ramp

Unexpected sender

A parent company in Spain pays its Mexican subsidiary's invoice

If monitoring flags the on-ramp, it is held while compliance asks about the relationship and the purpose; with no answer in 24 hours, it may be refunded to the sender

Below the minimum

A payer tests a static Pix code with a few reais

Deposits under the documented minimum are not converted, and the docs send the case to support@lumx.io

Wrong network

A payer sends USDT to the customer's Base address

The docs list Base as USDC only and Tron as USDT only, so the payment page should never offer that pair

What should a platform do when a payer underpays or overpays?

An amount mismatch is only possible when the payer chooses the amount. With a per-invoice collection, the payment code carries the amount, so the payer pays what you asked. With a standing instruction, such as a static Pix (Brazil's instant payment system, run by the Central Bank) code or a CLABE (the 18-digit Mexican bank account number) reused for every payment, the payer types the amount, and the provider converts whatever arrives.

That means the provider will not tell you a deposit is "short". It converts 9,500 reais as faithfully as 10,000. The invoice logic lives in your product, and three policies cover almost every case:

  1. Accept and close. Below a small tolerance you set per currency, mark the invoice paid and absorb the gap.

  2. Accept and request a top-up. Credit what arrived, keep the invoice open for the balance, and send the payer a new instruction for the difference.

  3. Return. For a regulated or contractual amount, such as a security deposit, refund the full payment and ask for the exact amount again.

For an overpayment, the choice is between holding the excess as credit on the payer's next invoice or refunding it. A refund is a payout, not an undo: the money has already been converted, so it goes back out as a new transaction to the payer's bank account, and the payer receives the local-currency value at that day's rate, which will not match what they sent to the cent. Write that sentence into the refund email: a payer who sent R$10,500 and sees, say, R$497 come back for the R$500 extra will open a dispute unless the email told them first.

When the amount matters to the cent, use a per-invoice collection with the amount fixed, and keep standing instructions for top-ups and recurring payers. The trade-off between the two models is in named accounts versus one-time deposit instructions.

What happens to a payment that arrives after the collection expired?

A per-invoice collection has a payment window. When it closes, the provider stops waiting for that money. If the payer pays afterwards, the deposit has nothing to match, and a well-run provider sends it back to the sender on the same rail rather than leaving it in limbo.

Your product needs two things here. The first is to show the deadline to the payer in their own time zone, next to the payment code, because "valid for one day" means nothing on a checkout page. The second is to listen for the expiry event and move the invoice to "expired, reissue" automatically, so the payer gets a fresh code instead of an error. From the payer's side, a refunded late payment looks like a bounced payment, so the message with the new code should say the first one is on its way back and when to expect it.

A late payment on a standing instruction is not late at all: the instruction never expires, so the deposit converts at the rate of the moment it arrives. That is the hidden cost of standing instructions. The invoice may say one thing about the rate, but the rate is whatever the market says when the money lands.

Missing references and unexpected payers

A deposit without its reference is the most common matching failure on rails where the payer types the reference by hand. On SPEI (Mexico's interbank transfer system, run by Banxico), the reference travels as a free-text memo next to the CLABE. On US wires, the memo is the only thing that ties a transfer to a specific collection.

What happens next depends on how the account is set up. If the account takes deposits for one purpose, the provider can still credit the money to the right customer and convert it, and your ledger only has to decide which invoice it pays. If one account serves several invoices, the money arrives as an orphan, and someone has to place it by amount and date, then by payer name. Build a screen for that person before launch, not after the first orphan arrives.

An unexpected payer is a compliance question, not a matching one. A group treasury paying for a subsidiary, a director paying from a personal account or a buyer's agent paying on their behalf is normal commerce, and collections on behalf of your customers (POBO and COBO) are a standard model. But a payer that does not fit the expected flow of funds can trigger a review, and an unanswered review can end with the money returned. Tell your customers which payers you expect before they share their details, and route any RFI (request for information, a compliance hold that asks for a document before a transaction clears) to a named person the same day.

I recommend that a platform writes its exception policy as a short table in the customer contract, not only in the support runbook. When the customer has already agreed that an overpayment is credited to the next invoice and an underpayment keeps the invoice open, support stops negotiating each case, and the payer gets the same answer from everyone. Which policy you choose matters less than having it in writing.

Wrong network and wrong stablecoin

Stablecoin pay-ins have a failure that bank rails do not: the payer can send the right stablecoin on the wrong blockchain. USDC exists on many networks, and on the networks that share the same address format, a payer's wallet will send to an address on a network the receiver never offered.

The receiver cannot always recover that money quickly. Whether it can be moved depends on who controls the address on that other network and whether the custodian supports it, and that is a manual case, not a status in an API. The only reliable fix is prevention:

  • Show the network and the stablecoin together, every time, next to the address, and never an address alone.

  • Offer one address per network, and say which stablecoins each network takes. USDC and USDT do not run on every network.

  • Ask the payer to send a small test amount first on a first payment from a new wallet.

  • Reconcile stablecoin deposits by balance and by the transfer hash, so you can prove what arrived when a payer insists they paid.

The choice of network itself is covered in USDC versus USDT for payments, and who pays the network fee is in who pays network fees.

Design the ledger around exceptions

A collection ledger that only knows "pending" and "paid" will turn every exception into a support ticket. Give each invoice a state machine that matches the exceptions above: open, partially paid, paid, overpaid, expired, returned, on hold and unmatched. Then drive it from the provider's events, not from polling and not from the payer's screenshot.

Three habits keep it honest. Put your own invoice or order id into the collection's metadata, so every event carries it back. Deduplicate events by their delivery id, because a webhook can arrive more than once. And send an idempotency key on every request that creates a collection, so a retried call after a timeout never produces two payment codes for one invoice. The mechanics are in stablecoin API webhooks and idempotency keys, and the month-end side is in virtual account reconciliation.

When a stablecoin pay-in is the wrong way to collect

Some payments should not go through a stablecoin pay-in at all, and pretending otherwise creates exceptions by design.

A consumer checkout that must accept cards needs a card acquirer. A payer who will only pay by direct debit cannot be served by a push-only collection, since the payer has to start the transfer. An invoice that must be paid to the cent in a currency the payer does not hold will produce underpayments every month, because the payer's bank takes its own fees on the way out; a per-invoice collection in the payer's local currency is the fix. And a business that never needs a stablecoin balance, because it spends everything locally, can keep a local bank account and skip the conversion.

How Lumx handles each exception on BRL and MXN collections

Lumx is stablecoin payments infrastructure for businesses that move money between Latin America and the rest of the world: one API to collect, hold, convert, and pay out in BRL, MXN, COP, USD, EUR, and GBP or in USDC and USDT, over local rails such as PIX, SPEI, PSE, Bre-B, ACH, FEDWIRE, SEPA, and Faster Payments, with SWIFT and on-behalf-of payments and collections (POBO and COBO) in USD, EUR, and GBP, plus named virtual accounts, custodial wallets, and KYB/KYC built in.

On Lumx, a collection is either an on-ramp, created per invoice with the amount set in the request, or an autoconversion rule on the customer's named virtual account, which returns a static Pix code or a CLABE plus memo that the payer reuses. Every matched deposit runs as an on-ramp and reports through onramp webhook events, from awaiting funds to success, failed or expired, with your metadata on each event. A locked on-ramp expires with its quote.

On Pix, the matching identifier is embedded in the code, so the payer cannot leave it out. On SPEI, the memo is what matches a deposit to a rule, so the payment page has to show it next to the CLABE. The other exceptions behave as the example table above shows. The rails per currency are on Lumx coverage, and a BRL collection end to end is on BRL to USDC.

Methodology and sources

Lumx behavior comes from docs.lumx.io read on November 17, 2026: transactions (payment expiration and late deposits), concepts/accounts, concepts/wallets, concepts/destinations, autoconversion rules, guides/use-cases/collect-brl-via-pix-settle-in-stablecoins, transaction RFI, developer/webhooks and developer/idempotency. The exception taxonomy and the policies are our own recommendation for platforms, not a regulatory requirement.

Verified on November 17, 2026. Operational context, not legal, tax, or investment advice.

Cover photo: Luca Upper on Unsplash.

  • What happens to a failed stablecoin pay-in?

    It depends on why it failed. A payment that lands after the collection expired is usually returned to the sender on the same rail, a deposit under the provider's minimum is not converted, and a payment flagged by compliance is held until someone answers the request for information. On Lumx, a late deposit is refunded to the original sender on the same rail, and the retry is a new on-ramp.

  • What should a platform do when a payer underpays an invoice?

    Decide the policy before go-live: accept within a small tolerance, keep the invoice open and request a top-up, or return the payment and ask for the exact amount. A provider converts whatever arrives on a standing instruction, so the invoice logic sits in your product. On Lumx, a per-invoice on-ramp fixes the amount in the payment code, which removes the mismatch for invoices that must be exact.

  • Can a payer send USDC on the wrong network?

    Yes, and it is the hardest exception to fix, because recovering the funds depends on who controls the address on that other network and whether the custodian supports it. Prevent it by always showing the network next to the address and offering one address per network. On Lumx, each customer has one wallet per supported network, and the docs list which stablecoin runs on which network.

  • How do you refund an overpaid stablecoin pay-in?

    As a new payout to the payer's bank account, since the money has already been converted. The payer receives the local-currency value at the day's rate, which will not match the original amount to the cent, so say so in the refund message. On Lumx, the refund is an off-ramp to a destination registered with the holder relationship CUSTOMER.

  • Why was a stablecoin pay-in returned to the sender?

    The usual reasons are an expired collection, an unanswered compliance review, or details the receiving bank rejected. Each one needs a different retry: a new collection, an answer to the review, or corrected details from the payer. On Lumx, an unanswered transaction RFI may be refunded to the sender after 24 hours, and a late deposit is returned on the same rail.

Stay up to date with what Lumx is developing.

Sign up to receive them by email.

Share on socials:

failed-stablecoin-payins-underpaid-late-wrong-network

A

failed-stablecoin-payins-underpaid-late-wrong-network

Failed stablecoin pay-ins: underpaid, late or on the wrong network

Copy link

Copied!

failed-stablecoin-payins-underpaid-late-wrong-network

TALK TO OUR TEAM

Ready to transform your business with stablecoins?

Discover how our infrastructure can seamlessly integrate stablecoins into your financial operations quickly, securely, and efficiently.

Guides

In this page

©2026. All rights reserved.

Lumx US OP LLC ("Lumx") is a financial technology and payments infrastructure company. Lumx US OP LLC is a Money Service Business (MSB) registered with the Financial Crimes Enforcement Network (FinCEN) (MSB #31000316459619). Lumx is not a state-licensed money transmitter and does not, in its own capacity, engage in the provision of regulated money transmission services. All such regulated activities are conducted exclusively through, and under the licenses of, duly authorized financial-institution partners.


Lumx is not a bank, financial institution, payment institution, or custodian of client funds. Certain services made available through the Platform may be provided by duly authorized and regulated third-party partners, in accordance with applicable laws and regulations.

Please refer to Lumx’s Terms of Use and Privacy Notice for further information regarding the conditions governing the use of the Platform and the processing of your personal data.