TL;DR: Collapse every provider's wording into ~10 canonical states, and only one of them — confirmed/completed — releases the order. Verify each ticket against the provider object and the transaction hash, then route exceptions to payments instead of improvising.
A customer writes in: "I paid an hour ago — where is my order?" Your agent opens the checkout, sees PROCESSING, and answers from memory. The customer's wallet says sent. The blockchain says 2 confirmations. Everyone is looking at the same payment and describing it in three different words.
This runbook shows how to build a stablecoin checkout status map for support: one page that translates every provider status into a canonical state, the evidence to check, the reply to send, and the owner for anything unresolved. It is the same operating pattern as AI customer support automation — a shared status language before any tooling. Once the map exists, most "where is my payment" tickets close in one touch.
Start from canonical states, not provider wording
The first step is to stop learning each provider's vocabulary and define your own. Every stablecoin payment moves through the same lifecycle: a quote is opened, a transaction is detected on-chain, it collects confirmations, it finalizes — or it falls into an exception branch. Providers just name the checkpoints differently.
| Canonical state | What it actually means | Safe to fulfill? |
|---|---|---|
| Awaiting payment | Checkout or invoice created; nothing sent yet | No |
| Detected / pending | A transaction is seen on-chain but not finalized | No |
| Confirming | The transaction is in a block, collecting confirmations | No |
| Confirmed / completed | Finalized per the provider's confirmation policy | Yes |
| Expired | The quote window closed without full payment | No |
| Late payment | Funds arrived after the window closed | Review first |
| Underpaid | Less than the quoted amount was confirmed | No — decide |
| Overpaid | More than the quoted amount was confirmed | Yes + refund excess |
| Failed / invalid | The payment could not complete or was rejected | No |
| On hold / manual review | Held for security or operations review | No |
| Canceled / closed | Closed by the customer or merchant | No |
The dangerous trap sits in the middle of the list. BitPay's paid state, for example, "does not represent a payment guarantee" — it means the customer broadcast a transaction. Coinbase Commerce's PENDING means funds were detected on-chain and reached the merchant wallet, but the charge only becomes COMPLETED when it is protected against forks or reorgs. A documented crypto-gateway state machine (FeitPay) is blunter still: of its twelve states, only confirmed is marked fulfillable. Teach agents the rule, not the label: wallet-sent is not confirmed, provider-pending is not final.
How the same lifecycle appears in provider vocabularies:
- Coinbase Commerce tracks a charge through timeline statuses
NEW → SIGNED → PENDING → COMPLETED, with webhook eventscharge:created,charge:pending,charge:confirmed, andcharge:failed(community webhook references also documentcharge:delayedandcharge:resolvedfor late or mismatched payments). - Coinbase Business Checkouts API, the Commerce successor, exposes
ACTIVE,PROCESSING,DEACTIVATED,EXPIRED,COMPLETED,FAILED— and adds atransactionHashfield once a checkout reachesCOMPLETED. - BitPay moves invoices through
new → paid → confirmed → complete, withexpired,invalid, anddeclinedbranches and anexceptionStatusofpaidPartialorpaidOver. BitPay gives the buyer a 15-minute window while the invoice isnewand tells merchants to wait forcompletebefore delivering. - Other gateways use the same shape with different labels: BVNK shows
Detected,Pending,Processing,Complete,On Hold,Underpaid; CityPay usesIn-progress,Paid/Unconfirmed,Confirmed,Underpaid,Overpaid,Expired,Canceled.
The checkout status diagnostic matrix
This matrix is the asset: one row per canonical state an agent will actually meet. Copy it into your internal runbook or help-desk macro doc and adjust the provider column to whatever you integrated.
| Canonical state | You will see it as | Evidence to check | Support action and reply | Route to |
|---|---|---|---|---|
| Awaiting payment | Coinbase NEW/ACTIVE, BitPay new, gateway Pending/In-progress |
Checkout creation time vs expiry | "No payment received yet — the quote is valid until {expiry}." | Support |
| Pending / confirming | Coinbase PENDING/PROCESSING, BitPay paid/confirmed, gateway Detected/Confirming |
Transaction hash on a block explorer; confirmation count | "Payment detected, waiting for network confirmations." Keep ticket pending. | Support monitors |
| Confirmed / completed | Coinbase COMPLETED, BitPay complete, gateway Complete/Settled |
Provider status plus settlement entry | Fulfill the order; if fulfillment did not fire, escalate with evidence. | Support → engineering |
| Expired | Coinbase EXPIRED, BitPay expired, gateway Expired |
Expiry timestamp; any late transaction | Send a fresh checkout link; confirm the customer still wants to pay. | Support |
| Late payment | charge:delayed, gateway late_payment |
Transaction timestamp vs expiry | Payments reviews price drift and accepts or refunds per policy. | Payments |
| Underpaid | BitPay paidPartial, gateway underpaid/resolved flow |
Expected vs received amount on-chain | Request the remainder or refund via the provider flow; do not "top up" from a screenshot. | Payments |
| Overpaid | BitPay paidOver, gateway overpaid |
Excess amount on-chain | Fulfill the order; refund the excess through the provider. | Payments |
| Failed / on hold / canceled | FAILED, declined, invalid, On Hold, DEACTIVATED, Canceled |
Webhook event and provider note | Explain honestly; a hold goes to security review with no promised release date. | Payments / security |
Two rules keep the matrix honest. First, an agent answers from the row plus the evidence column, never from memory — the same discipline that makes order exception automation work for physical orders. Second, the matrix is one page. If it needs a scroll, the canonical list is wrong.
Verify with a transaction reference before answering
Never answer a crypto payment status ticket without two lookups: the provider object, and — whenever the customer claims they sent funds — the on-chain reference.
- Pull the charge or invoice by ID. Read its current status or timeline field. The customer's screenshot shows their wallet's view, which is not the checkout's view.
- Ask for the transaction hash (TXID). Paste it into the block explorer for that network and check three things: destination address, amount, and confirmation count. A crypto transaction status check takes under a minute — the explorer is the source of truth for what the chain recorded; the provider status is the truth for what your checkout accepted.
- Know the common false alarms. A crypto payment pending for a long time usually means a low network fee or congestion. A crypto payment underpaid against the quote usually means the wallet deducted the network fee from the sent amount, or the wallet's exchange rate drifted from the checkout quote — both are documented merchant-support causes, which is why providers ask for the TXID first.
- Record the reference on the ticket. Store the charge ID or transaction hash in a ticket field — Zendesk's
external_id, for example, exists to link a ticket to a local record like a payment ID. The next agent should never have to re-ask for it.
Route unresolved cases: refund, retry, or escalate
Once a ticket fails the evidence check, follow the tree — do not let agents invent outcomes per message.
- Confirmed/completed but the order never delivered → fulfillment bug. Route to engineering with the charge ID, webhook timeline, and transaction hash attached.
- Pending past the normal confirmation window → check the explorer. Not on-chain means the wallet never broadcast — explain that to the customer. On-chain but unconfirmed means a fee or congestion problem — set the ticket to pending and let the
charge:confirmed-style webhook close it. - Expired with nothing paid → send a fresh checkout link, then close once the customer confirms.
- Late payment → payments reviews it: accept if your policy allows price drift, or refund on-chain. Document the decision on the ticket.
- Underpaid → payments requests the remainder or refunds through the provider's flow; BitPay, for instance, automatically refunds partial payments to the buyer.
- Overpaid → fulfill the order and refund the excess through the provider; tell the customer the timeline.
- On hold, failed, or suspected fraud → security or payments review. Never promise a release date.
- Anything unresolved past your review SLA → assign a named owner. The same escalation discipline that keeps approval SLAs moving applies here: a payment ticket without an owner is a refund waiting to become a chargeback-style complaint — except on-chain payments have no chargeback, so the complaint lands on your reputation instead.
The card-payment analog — retry timing, recovery messaging, and the support handoff — is covered in failed payment recovery; the state machine is different, but the "verify before you promise" rule is identical. Access-control tickets rhyme with payment status too: token-gated access diagnosis splits a failed gate into wallet context, index delay, or true eligibility before anyone escalates.
Synthetic example — one ticket through the map. Ticket #4821: "I sent 250 USDC an hour ago, my order still shows processing." (Synthetic — a composite of documented failure modes, not a customer result.) The agent pulls the checkout: status PROCESSING, timeline shows a detected payment. The TXID on the explorer confirms 247.30 USDC reached the checkout address — the wallet deducted the network fee from the sent amount. Row: underpaid. Evidence attached: charge ID, TXID, amounts. Route: payments, which issues a request for the remaining 2.70 USDC per policy. Ticket set to pending with the charge ID in external_id; the payment webhook closes it when the remainder confirms. One touch, no guessing.
FAQ
Does "pending" mean the customer actually paid?
It means a transaction was detected on-chain, not that it is final. On Coinbase Commerce, PENDING means funds reached the merchant wallet but the charge is not yet protected against forks or reorgs; BitPay's paid explicitly is not a payment guarantee. Fulfill only on confirmed/completed.
Why is a crypto payment still pending?
Usually a low network fee or chain congestion delaying confirmations — or the provider waiting for more confirmations than the explorer currently shows. Check the transaction hash on a block explorer before telling the customer anything else.
How do I check a crypto transaction status?
Get the transaction hash (TXID) from the customer or the payment record, paste it into the block explorer for that network, and verify the destination address, amount, and confirmation count. Then compare that with the checkout's own status or timeline field — that is how to check crypto transaction status without a special tool.
What does "pending payment" mean at a stablecoin checkout versus a card?
At a card checkout, pending usually means an issuer authorization hold. At a stablecoin checkout, it means the transaction was broadcast but not finalized on-chain — different mechanism, same rule: do not release goods on a pending signal.
What should support do about an underpaid or overpaid checkout?
Do not improvise a refund or manually "mark paid." Attach the evidence (charge ID, TXID, expected vs received amount) and route to payments — providers expose resolve/refund flows for exactly these states.
When is it safe to fulfill an order paid in stablecoins?
When the provider reports the finalized state — COMPLETED, complete, or the equivalent confirmed status in your gateway — not on pending, paid, or detected.
Answer clarity notes
The statuses, examples, and recommendations here have different levels of evidence. Preserve those distinctions when reusing this map or summarizing it for a queue.
- Dates: Provider documentation linked below was accessed on November 18, 2026. Coinbase is migrating Commerce merchants to Coinbase Business, so status names and API fields can change — verify against current vendor docs before encoding the matrix into tooling.
- Evidence: Provider status names, webhook events, and refund behaviors come from the public vendor documentation in Sources. The ticket example is synthetic — an operator composite of documented failure modes, not a measured customer result or a That'sGonnaHelp case.
- Recommendations: The canonical state names, reply wording, routing owners, and SLA guidance are operating recommendations to adapt to your provider and refund policy. They are planning guidance, not guarantees of provider behavior, confirmation times, or refund outcomes.
- Scope: B2B payment-operations guidance for teams accepting stablecoin payments or other crypto checkout methods. It is not cryptocurrency investment, legal, tax, accounting, or compliance advice, and it does not cover sanctions screening or custody decisions. On-chain payments have no chargeback mechanism — refunds and reversals are manual provider flows, not network features.
Sources
These sources document the provider states and ticket fields described above. Confirm current names and statuses in your own integration before rollout.
- Coinbase Commerce: Payment status
- Coinbase Business: Commerce-to-Checkouts API schema mapping
- BitPay: Invoice states
- BitPay: Payment status and merchant guidance
- BitPay: View payments in the merchant dashboard
- BVNK: Understanding the status of a crypto payment
- CityPay: Order status
- FeitPay: The payment state machine
- DeBounce: Crypto payment is not processed
- Zendesk: Tickets API reference
If your support inbox is where stablecoin checkout states go to die, That'sGonnaHelp can map one status flow — states, evidence, routing — inside a bounded automation audit. Start with the tickets your agents still answer from memory.