If you run an online store, you have probably received the same message from support more than once: "Can I pay with USDT?" The buyers asking are usually from Southeast Asia, the Middle East, Latin America or Eastern Europe — regions where card penetration is low and where PayPal frequently declines or freezes merchant accounts. Adding a crypto checkout is not about chasing a trend; it is about catching orders that would otherwise be abandoned at the payment step.
There is a common misconception, though: many merchants assume accepting USDT just means pasting a wallet address onto the checkout page. In practice you run into manual reconciliation, mismatched amounts, and wrong-chain transfers where the gas fee costs more than the order itself. This guide breaks the integration down into steps you can actually execute.
Why online stores keep adding USDT checkout
- Reach customers that card networks exclude: low card penetration regions, and categories that traditional processors flag as high risk, are either declined outright or stuck in lengthy reviews.
- No chargebacks: once an on-chain transfer is confirmed it cannot be reversed, so you are never dragged through a "refund first, argue later" dispute process.
- Instant settlement: no T+7 payout cycle. When the transaction confirms, the funds are already in your own wallet.
- Predictable cost: your cost is on-chain gas plus the gateway fee — no 3% currency-conversion markup at the end of the month.
Step 0: Decide three things before you write any code
1. Custodial or non-custodial
With a custodial setup, the platform collects payments and settles to you later. That means the platform's counterparty risk becomes your risk: if it is breached, shuts down, or gets its accounts frozen, your money is stuck with it. In a non-custodial setup, funds move through a smart contract straight from the buyer to your wallet; the gateway only generates invoices and sends notifications. For a store, the first benefit of non-custodial is not lower fees — it is that the platform having a bad day does not stop you from getting paid.
2. Invoice payments or deposit addresses
Invoices create a unique amount, address and expiry per order — ideal for one-off payments on physical or digital goods. Deposit addresses assign each user a permanent address so they top up a balance first and spend later — ideal for SaaS credits, memberships and in-game items. Invoices are simpler to integrate; get them working before you build a balance system.
3. Which chain to open
Tron has the cheapest USDT transfers and the largest holder base, which makes it the best default for small tickets. EVM chains (Ethereum, BSC, Polygon, Arbitrum, Base) suit buyers who already hold an EVM wallet; gas on Base, Polygon and BSC is now very low. In practice: open Tron by default for small, frequent orders, and enable at least one EVM chain once your average order value goes above a few hundred dollars.
The four steps to your first payment
Step 1 — Register and get your credentials
After your merchant account is approved, the credentials page gives you an AppID and an HMAC key. Note that the HMAC key is shown in plaintext only once. Store it in a server-side environment variable immediately; never ship it to the browser and never commit it to a repository.
Step 2 — Create the invoice server-side
The endpoint is POST /v1/invoice. The request body needs only a few fields: out_no (your own order ID, used for idempotency — must be unique within your store), title, currency, amount, plus optional duration (how long the payment window stays open) and return_url (the synchronous redirect after payment). Signing uses HMAC-SHA256 over nonce + timestamp + body, and the request carries XC-Appid, XC-Timestamp, XC-Nonce and XC-Signature headers. Full field reference, a worked numeric signing example and Python / PHP / cURL samples live in the API docs.
Step 3 — Hand the payment link to the buyer
The response contains a pay_url — the hosted checkout. Redirect to it, or render it as a QR code for mobile buyers. Never rebuild the amount or address on the client: amount, currency and expiry are inside a signed token, so any client-side edit invalidates it. That signature is what makes the link tamper-proof.
Step 4 — Receive the callback and settle the order
On success the gateway POSTs to the webhook URL you configured. Three things matter when handling it:
- Verify
XC-Signaturewithhash_equals(a constant-time comparison) — not==. - Make the handler idempotent on
out_no, so a retried delivery never credits the same order twice. - Respond with
HTTP 200and a body strictly equal took(lowercase). Anything else is treated as a failed delivery and retried.
Callbacks can be lost to network hiccups, so add a fallback: a scheduled job, or a status check triggered when the buyer reloads the payment page, calling GET /v1/invoice/{sys_no} to reconcile any payment that was confirmed on-chain but never delivered. Webhooks plus active polling — you need both if you want to guarantee you never miss an order.
Three ways to integrate
| Approach | Coding required | Best for | Effort |
|---|---|---|---|
| API integration | Yes (server-side) | Stores with a backend that want automated reconciliation | Half a day to a day |
| Static payment button | No | Static sites, theme templates, selling from a community post | A few minutes |
| Deposit addresses | Yes (server-side) | SaaS credits, memberships, in-game items | Half a day |
The five mistakes most merchants make
- Floating-point money: doing amount math in floats produces values like
0.30000000000000004, and your reconciliation will be off by fractions forever. Keep amounts as strings or fixed-point decimals, and compare with an exact-decimal library. - Wrong address format: EVM receiving addresses must use EIP-55 checksum casing. All-lowercase addresses get rejected by some wallets and libraries.
- Shipping on a single confirmation: do not fulfil the moment a transaction appears on-chain. For larger tickets, wait for 6–12 confirmations so a chain reorg cannot leave you with goods gone and payment gone.
- Webhooks only, no polling: one dropped callback is one permanently lost order. Active status queries are a requirement, not a nice-to-have.
- Shipping the HMAC key to the browser: once leaked, anyone can create invoices in your name. Keep the key server-side; give the browser only a pre-signed payment token.
Bottom line
Accepting USDT is not the hard part. Getting four things right is: amount precision, address format, idempotent callbacks, and active status polling. Choose a non-custodial gateway, launch with invoices, and add deposit addresses only when your product needs a balance model.
For the full endpoint reference and copy-paste samples, see the API documentation. If you have not signed up yet, the home page lists supported chains and plans — after registering you can run a first test payment in minutes.