What Is a Crypto Payment Gateway? How It Works
A crypto payment gateway turns a blockchain transfer into a paid order. Here's what happens at each step, how custodial and non-custodial models differ, and what to check before you pick one.
If you sell anything online, sooner or later someone asks whether they can pay in USDT, and you'll start reading about the crypto payment gateway. It's the software between your checkout and the blockchain that turns a transfer from a stranger's wallet into a paid order in your system. Below is what it does at each step, where the tricky parts are, and what to check before you choose one.
What a crypto payment gateway actually does
With cards, the processor does the hard work and sends you a "payment succeeded" event. Crypto is push-based: the customer sends money to an address, and nobody tells you it arrived unless something is watching. A gateway does that watching, and handles the work around it.
A typical payment goes through six stages:
- Invoice. Your server tells the gateway "order 1042, 25 USDT". The gateway creates a payment record with an amount, a currency and an expiry time.
- Address assignment. The gateway picks where the customer should send funds and shows it on a checkout page, usually as a QR code plus the address and amount.
- Detection. It watches the chain for incoming transfers to that address.
- Confirmation. It waits until the transfer is final, meaning it can no longer be reversed.
- Notification. It tells your server, usually with a webhook, so you can ship the order.
- Settlement. The money ends up somewhere you control, either straight in your own wallet or in a balance you withdraw later.
On your side, the integration is usually a single API call. Here's what it looks like with TillCrypto; most gateways are similar:
curl https://api.tillcrypto.com/v1/payments \
-H "Authorization: Bearer sk_live_..." \
-H "Content-Type: application/json" \
-d '{
"amount": "25.00",
"currency": "USDT-TRC20",
"order_id": "1042",
"success_url": "https://yourshop.com/thanks",
"cancel_url": "https://yourshop.com/cart"
}'The response includes an id, a status of pending and a checkout_url. You redirect the customer to that URL, and from then on the gateway handles stages 2 to 6. The full walkthrough is in how to accept USDT payments on your website.
How a gateway matches a transfer to an order
People tend to underestimate this part. A blockchain transfer has no order number. Most wallets don't let the customer attach a reference, and plenty of customers wouldn't fill one in anyway. So the gateway has to work out which order a transfer belongs to from the address and the amount alone.
There are two common ways to do it:
| Unique address per invoice | Address pool + exact amount | |
|---|---|---|
| How it matches | Every order gets a fresh address; whatever arrives there belongs to that order | Orders share a set of addresses and are matched on address plus exact amount; the amount is nudged only on a collision |
| Strengths | Matching is trivial, and even a wrong amount is clearly tied to one order | Far fewer addresses to manage, fund and sweep |
| Weak spots | Every address needs gas to move funds out later, and that cost grows with volume | The customer must send the exact figure; a short or rounded payment won't match automatically |
TillCrypto, for example, uses a variant of the second approach: a pool of addresses, matched on address plus exact amount. If a second customer opens a 100.00 USDT payment while the first is still open, they usually get a different address. Only when every address already has an open 100.00 payment is the amount nudged to 100.01. Either way, sending "roughly 100" won't match.
Detection and confirmation: when is "paid" really paid?
Spotting a transfer is not the same as being able to trust it. A transaction can be broadcast and never included, or included in a block the network later drops. A good gateway only marks an order paid once the transfer is final.
How long that takes depends on the chain. TRON produces a block about every three seconds, and a block becomes irreversible ("solidified") once at least 19 of its 27 Super Representatives have produced blocks on top of it, which usually takes about a minute. On Ethereum, proof-of-stake finality takes about two epochs of 6.4 minutes each, so roughly 13 minutes. These differences are a big reason TRC20 USDT is popular for small merchant payments. Our comparison of TRC20, ERC20 and BEP20 covers the rest.
There's also a security check that's easy to miss. Anyone can deploy a token named "USDT". The name means nothing; what matters is the token contract address. Tether publishes the official contract addresses for the chains it issues on (TRON and Ethereum among them). On BNB Chain, USDT is a bridged token, so check the address the gateway documents. A gateway that checks the token's name instead of its contract can be fooled by a worthless copy.
Webhooks: how your shop finds out
Once a payment is confirmed, the gateway sends an HTTP request to your server. That webhook is what should trigger fulfilment. A solid implementation has a few properties:
- Signed. The request carries an HMAC signature computed with a secret only you and the gateway know, so nobody else can fake a "paid" event.
- Timestamped. The signature covers a timestamp, so an old request captured and replayed later can be rejected.
- Retried. If your server is down or returns an error, the gateway tries again on a backoff schedule instead of giving up after one attempt.
- Identifiable. Each event has an ID, so you can safely ignore duplicates.
- Resendable. You can trigger a resend from a dashboard after fixing a bug on your side.
Verifying signatures properly (raw body, constant-time compare, timestamp tolerance) is short to write but easy to get subtly wrong. We walk through it in how to verify crypto payment webhooks.
Custodial vs non-custodial crypto payment gateways
This is the biggest structural difference between gateways, and it's the first thing to pin down.
A custodial gateway receives payments into addresses it controls. Your money becomes a balance in its ledger, and you request a payout when you want it on-chain. A non-custodial gateway sends funds straight to addresses you control, often derived from a public key you give it, and only does the watching and notifying.
| Custodial | Non-custodial | |
|---|---|---|
| Who holds the keys | The gateway operator | You |
| Setup | Sign up and get an API key | Also set up and secure your own wallet |
| Getting funds out | Request a payout; the operator sends it | Already in your wallet |
| Wrong amounts, refunds | Operator can review and adjust balances | You handle them from your own wallet |
| Main risk | You depend on the operator to hold funds and pay out | You're responsible for key security and gas |
Neither is automatically better. Custodial is simpler to run, especially if you don't want to manage keys or keep gas tokens topped up. Non-custodial removes the counterparty, but you take on the operational work. Also check what "non-custodial" really means: if the gateway generates your private keys on its own servers, it isn't non-custodial.
To be upfront about our own setup: TillCrypto is custodial. Payments land in platform-managed addresses and are credited to your merchant balance; you request a payout from the dashboard or API, it's reviewed, sent on-chain, and the transaction hash is recorded. With any custodial service, a sensible habit is to withdraw regularly instead of keeping a large balance there.
What to look for when choosing a crypto payment gateway
Most feature pages list the same things. The differences show up in these questions:
| Area | What to ask | Red flag |
|---|---|---|
| Fees | Processing %, payout fees, monthly fees, all together at your volume | Fees only visible after signup |
| Networks | Which networks and tokens are live today, not "coming soon" | Vague list of logos |
| Webhooks | Signed? Retried? Manual resend? A test event button? | Unsigned callbacks, single attempt |
| Test mode | Can you simulate a paid payment without spending money? | You must test with real funds |
| Edge cases | Underpayment, overpayment, wrong token, payment after expiry? | "That doesn't happen" |
| Payouts | How often, minimums, network fees, how you get proof | Unclear review times, no tx hash |
Edge cases deserve more attention than anything else in that table. Customers will pay late, pay twice, send the wrong token or come up a few cents short, and how the gateway handles that decides how much support email you get. Ask for specifics: is a payment that lands after expiry still credited, and within what window? Are wrong-coin or wrong-amount transfers kept for review or silently dropped? Our guide to crypto payment edge cases goes through each scenario.
On fees, add everything up. A 0% processing fee with a fixed per-payout fee can work out very differently from 1% with free payouts. At 2,000 USDT a month and one withdrawal, 1% is 20 USDT against a single 2 USDT payout fee. At 100 USDT a month with weekly withdrawals it flips: 8 USDT in payout fees against 1 USDT at 1%.
A quick test before you commit
You can learn most of what matters about a gateway in an hour or two:
- Create a test-mode payment through the API and simulate it as paid.
- Point the webhook at your server, verify the signature, and log the event ID.
- Shut your endpoint down, trigger another event, and watch whether retries arrive.
- Open the checkout page on a phone. Can a customer scan, copy and pay without getting confused?
- In live mode, make one small real payment (large enough to cover the payout fee, say 10 USDT) and then request a payout. Check the fee and the on-chain transaction.
If all five go smoothly, you'll have found the rough edges before your customers do.