₮ USDT Payment Portal
Non-custodial · Multi-chain · Fee-free

Non-custodial crypto payment gateway

Invoice and deposit payments settle straight to your own collection address

No custody at any point, with support for all major EVM chains and Tron. Funds reach your wallet through smart contracts, so a database leak still cannot move a single coin. Pick a plan and start — no transaction fees, only on-chain gas at actual cost.

Checkout · Live EVM + Tron
Amount due
29.99 USDT≈ $29.99
Choose an asset
USDT · Tron USDT · Base USDT · BNB
Receiving address
TU9UkV…Ji13U Smart contract
Awaiting payment 14:52 Risk score · Low
0%
Fee-free transactions
100%
Non-custodial
EVM + Tron
Multi-chain, multi-asset
Webhooks
Real-time payment events
Use cases E-commerce USDT top-ups Cross-border settlement SaaS billing Wallets & exchanges

You are the only one in control of the funds

A non-custodial gateway that never holds assets behind a private key or mnemonic. Every payment flows through a smart contract into your merchant wallet, and the destination is fixed in code — it can only ever go to you. The platform only matches invoices, tracks status and sends notifications; it never touches the money. Because no private key ever guards an asset, a stolen database or a compromised server leaves nothing to steal.

👤
Buyer
Scans or transfers
🔒
Receiving contract
Destination fixed in code
🏦
Your collection address
Only you hold the key
Control plane Matches invoices, tracks status, sends notifications — never touches funds
Even if the database leaks or the server is breached
No asset is ever guarded by a private key. An attacker sees invoice data at most, cannot change the on-chain destination, and finds nothing to steal.

No key ever holds funds

Funds go straight to your merchant wallet. There is no key inside the system that could be stolen, because there is no asset to guard.

Straight to your wallet

The contract fixes the destination to your merchant wallet. It can only ever go to you, and nobody can rewrite it.

Minimal attack surface

The receiving contract does one thing: send funds to your collection address. Less logic means fewer ways in.

Invoice payments vs deposit payments

Two ways to receive money covering every scenario. Pick the one that matches your business.

Invoice payments

Fixed amount · Time limited

Each order creates a fixed-amount, time-limited invoice that completes once the buyer pays. Works with direct-to-wallet collection or smart contracts: receive into a project wallet, or give every invoice its own contract address with automatic collection.

  • Fixed amount, time-limited invoices
  • Direct-to-wallet or smart contract
  • Independent contract addresses for high concurrency
  • Great for checkout and subscription billing

Deposit payments

Exchange style · Dedicated address

Every end user gets a dedicated deposit address, shared across chains and monitored in real time. They can top up whenever they like and the balance is credited after block confirmation — no order needed, just like an exchange.

  • A dedicated address per user
  • Shared across chains, monitored live
  • Top up anytime, credited on confirmation
  • Built for wallets and trading businesses

Everything a payment gateway needs, out of the box

From invoice creation to settlement and notifications, one system covers it all.

Automatic collection

Funds are swept in batches by delay and amount thresholds, so each sweep costs about as much as a plain transfer and lands in your collection address automatically.

Multi-chain, multi-asset

All major EVM chains with any ERC-20 token, plus USDT and native TRX on Tron.

Smart contract collection

Give each invoice its own contract address, collected automatically after confirmation. Addresses never collide and sweeps cost about the same as a normal transfer.

Multiple merchants and projects

One instance isolates many merchants and projects, each with its own credentials, signing key and collection address.

On-chain risk scoring

Source addresses are risk-scored, and both the API and webhooks carry risk_level and risk_score.

Webhooks

Real-time invoice and deposit events, automatic retries, and nonce-based idempotency.

EPay V1 compatible

Supports the standard EPay protocol, so legacy integrations migrate without rewriting anything.

Public invoice query

An unsigned endpoint returns invoice status, handy for polling payment results in the front end and for reconciliation.

How it compares

Common crypto payment options side by side.

This platform Hosted processors BTCPay Server
Custody Non-custodial, straight to your wallet Collected, paid out on a settlement cycle Non-custodial
Platform fee 0 / Fee-free Typically 0.4%–1% per transaction 0
KYC / onboarding None Usually required None
EVM + Tron stablecoins Any ERC-20, incl. Tron USDT Depends on the provider Mostly BTC, plugin-extended
Exchange-style deposit addresses Built in Rarely available —
EPay V1 protocol Compatible — —
Subscriptions and prepaid billing Built in Per provider rules Needs custom work

Based on publicly available information; for reference only.

All major EVM chains and Tron

EVM chains accept any ERC-20 token such as USDT or USDC. Tron supports USDT and native TRX.

EVM chains

Any ERC-20 token
Ethereum BNB Chain Polygon Arbitrum Base Optimism More EVM

Tron

USDT and native TRX
USDT (TRC-20) TRX

The list of supported chains and assets keeps growing; see the merchant console for the current combinations.

A small, clean REST API Integrate in minutes

A RESTful API with HMAC-SHA256 request signing. A couple of calls create an invoice or issue a dedicated deposit address, while webhooks push every payment event with its risk score.

POST/v1/invoice
GET/v1/invoice/{sys_no}
GET/v1/deposit/address

The gateway URL in the examples is a placeholder. Find your real address and keys on the Credentials page, and the full reference under API Docs in the merchant console.

Signing headers
XC-AppidProject AppID
XC-TimestampUnix timestamp in seconds
XC-NonceUnique random string per request
XC-SignatureRequest signature (hex)

Signature = HMAC-SHA256(nonce + timestamp + raw body, HMAC_KEY), hex encoded. timestamp is a Unix timestamp in seconds and nonce is unique per request.

import hashlib, hmac, json, time, uuid, requests

API_BASE = "https://pay.example.com"
APPID    = "XC-XXXXXXXX"
HMAC_KEY = "your_hmac_key"

body = json.dumps({
    "out_no":   "order-20260101-001",
    "title":    "Premium Plan",
    "currency": "USD",
    "amount":   "29.99",
    "duration": 15,
}, separators=(",", ":"), ensure_ascii=False)

timestamp = str(int(time.time()))
nonce     = uuid.uuid4().hex
signature = hmac.new(
    HMAC_KEY.encode(),
    (nonce + timestamp + body).encode(),
    hashlib.sha256,
).hexdigest()

resp = requests.post(
    f"{API_BASE}/v1/invoice",
    data=body.encode("utf-8"),
    headers={
        "Content-Type":  "application/json",
        "XC-Appid":      APPID,
        "XC-Timestamp":  timestamp,
        "XC-Nonce":      nonce,
        "XC-Signature":  signature,
    },
)

print(resp.json()["pay_url"])     # 跳转到该地址完成付款
BODY='{"out_no":"order-20260101-001","title":"Premium Plan","currency":"USD","amount":"29.99"}'
TS=$(date +%s)
NONCE=$(openssl rand -hex 16)
SIG=$(printf '%s' "${NONCE}${TS}${BODY}" | openssl dgst -sha256 -hmac "$HMAC_KEY" -hex | awk '{print $2}')

curl -sS -X POST "$API_BASE/v1/invoice" \
  -H "Content-Type: application/json" \
  -H "XC-Appid: $APPID" \
  -H "XC-Timestamp: $TS" \
  -H "XC-Nonce: $NONCE" \
  -H "XC-Signature: $SIG" \
  -d "$BODY"
<?php
$body = json_encode([
    'out_no'   => 'order-20260101-001',
    'title'    => 'Premium Plan',
    'currency' => 'USD',
    'amount'   => '29.99',
    'duration' => 15,
], JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES);

$timestamp = (string)time();
$nonce     = bin2hex(random_bytes(16));
$signature = hash_hmac('sha256', $nonce . $timestamp . $body, $hmacKey);

$ch = curl_init($apiBase . '/v1/invoice');
curl_setopt_array($ch, [
    CURLOPT_POST           => true,
    CURLOPT_POSTFIELDS     => $body,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'Content-Type: application/json',
        'XC-Appid: '     . $appid,
        'XC-Timestamp: ' . $timestamp,
        'XC-Nonce: '     . $nonce,
        'XC-Signature: ' . $signature,
    ],
]);
$result = json_decode(curl_exec($ch), true);
header('Location: ' . $result['pay_url']);
import hashlib, hmac, time, uuid, requests
from urllib.parse import urlencode

timestamp = str(int(time.time()))
nonce     = uuid.uuid4().hex

# GET 请求没有 body,签名时用空字符串拼接
signature = hmac.new(
    HMAC_KEY.encode(),
    (nonce + timestamp).encode(),
    hashlib.sha256,
).hexdigest()

params = {"uid": "user-10001", "chain": "base", "crypto": "USDC"}
resp = requests.get(
    f"{API_BASE}/v1/deposit/address",
    params=params,
    headers={
        "XC-Appid":     APPID,
        "XC-Timestamp": timestamp,
        "XC-Nonce":     nonce,
        "XC-Signature": signature,
    },
)

print(resp.json()["deposit_address"])     # 展示给用户充值
TS=$(date +%s)
NONCE=$(openssl rand -hex 16)
SIG=$(printf '%s' "${NONCE}${TS}" | openssl dgst -sha256 -hmac "$HMAC_KEY" -hex | awk '{print $2}')

curl -sS -G "$API_BASE/v1/deposit/address" \
  --data-urlencode "uid=user-10001" \
  --data-urlencode "chain=base" \
  --data-urlencode "crypto=USDC" \
  -H "XC-Appid: $APPID" \
  -H "XC-Timestamp: $TS" \
  -H "XC-Nonce: $NONCE" \
  -H "XC-Signature: $SIG"
<?php
$timestamp = (string)time();
$nonce     = bin2hex(random_bytes(16));
$signature = hash_hmac('sha256', $nonce . $timestamp, $hmacKey);

$url = $apiBase . '/v1/deposit/address?' . http_build_query([
    'uid'    => 'user-10001',
    'chain'  => 'base',
    'crypto' => 'USDC',
]);

$ch = curl_init($url);
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER     => [
        'XC-Appid: '     . $appid,
        'XC-Timestamp: ' . $timestamp,
        'XC-Nonce: '     . $nonce,
        'XC-Signature: ' . $signature,
    ],
]);
$result = json_decode(curl_exec($ch), true);
echo $result['deposit_address'];
import hashlib, hmac
from flask import Flask, request

app = Flask(__name__)
seen = set()                       # 生产环境请换成 Redis 等持久化去重

@app.post("/xcash/webhook")
def webhook():
    raw       = request.get_data()
    nonce     = request.headers.get("XC-Nonce", "")
    timestamp = request.headers.get("XC-Timestamp", "")
    signature = request.headers.get("XC-Signature", "")

    expected = hmac.new(
        HMAC_KEY.encode(),
        nonce.encode() + timestamp.encode() + raw,
        hashlib.sha256,
    ).hexdigest()
    if not hmac.compare_digest(expected, signature):
        return "invalid signature", 401

    if nonce in seen:              # 按 nonce 幂等去重
        return "ok", 200
    seen.add(nonce)

    payload = request.get_json()
    if payload.get("type") == "invoice":
        data = payload["data"]
        credit(data["out_no"], data["pay_amount"])   # 按商户单号入账

    return "ok", 200               # 必须是 200 + 响应体 ok
# 用同一套 HMAC 口径本地复算签名,比较后再处理业务
RAW=$(cat /tmp/webhook_body.json)
TS="1735689600"
NONCE="6f1c2f2b8a5e4d3f9c0a1b2c3d4e5f60"
SIG=$(printf '%s' "${NONCE}${TS}${RAW}" | openssl dgst -sha256 -hmac "$HMAC_KEY" -hex | awk '{print $2}')

# 与请求头 XC-Signature 比对一致后,返回:
#   HTTP 200
#   响应体:ok
printf 'ok'
<?php
$raw       = file_get_contents('php://input') ?: '';
$nonce     = $_SERVER['HTTP_XC_NONCE']     ?? '';
$timestamp = $_SERVER['HTTP_XC_TIMESTAMP'] ?? '';
$signature = $_SERVER['HTTP_XC_SIGNATURE'] ?? '';

$expected = hash_hmac('sha256', $nonce . $timestamp . $raw, $hmacKey);
if (!hash_equals($expected, $signature)) {
    http_response_code(401);
    exit;
}

// 幂等:同一个 XC-Nonce 只处理一次
if (!nonceSeenBefore($nonce)) {
    $payload = json_decode($raw, true);
    if (($payload['type'] ?? '') === 'invoice') {
        $data = $payload['data'] ?? [];
        credit($data['out_no'], $data['pay_amount']);   // 按商户单号入账
    }
}

echo 'ok';     // 必须是 200 + 响应体 ok,否则网关判定投递失败
Webhook acknowledgement
Reply with HTTP 200 and a body of exactly ok. Anything else counts as a failed delivery; invoice notifications are not retried forever, so follow this contract.

Fits your existing stack

Anything speaking the standard EPay V1 protocol plugs in without rewriting its integration, and the REST API covers every other stack.

EPay ecosystem

Plug and play

Systems built on the EPay protocol — Xboard, V2board, card-selling panels, WHMCS and more — connect as-is.

Shops and site builders

Standard protocol

WordPress / WooCommerce and similar platforms connect through an EPay plugin with no custom development.

Plans · Fee-free transactions

Every plan is fee-free on transactions — you only pay the subscription. Plans differ in paid invoice limits and supported services.

🎁
Fee-free transactions
No transaction fees on any plan — you only pay the subscription, plus on-chain gas at actual cost.

Pick the plan that fits

Registration starts you on the free plan, and you can upgrade at any time with immediate effect.

免费

$0Free forever
  • RateFee-free
  • Paid invoices100
Get started
★

Pro

$19 / mo
/ yr: $190 Save 17%
  • RateFee-free
  • Paid invoices1,000
Upgrade

Max

$99 / mo
/ yr: $990 Save 17%
  • RateFee-free
  • Paid invoices10,000
Upgrade

无限

$199 / mo
/ yr: $1,990 Save 17%
  • RateFee-free
  • Paid invoicesUnlimited
Upgrade

FAQ

What is this?
A non-custodial crypto payment gateway. Invoice and deposit payments reach your collection address through smart contracts, and the platform never takes custody. Register in the merchant console, grab your credentials and integrate the API.
Do I need to deploy or maintain anything?
No. Chain scanning, invoice matching, collection scheduling and webhook delivery are all deployed and maintained by the platform. You only integrate the API and webhooks.
How is it different from BTCPay Server?
It covers all major EVM chains plus Tron, accepts any ERC-20 token, and can give every invoice its own contract address. It also ships exchange-style deposit addresses, per-merchant project isolation and on-chain risk scoring. BTCPay Server focuses on Bitcoin.
How are funds kept safe?
Payments flow through a smart contract with your collection address fixed as the destination. Even if the server is breached, the database leaks or configuration is exposed, funds stay safe as long as that address is untouched — the platform is only a control plane and never holds money.
Which assets are supported?
Any ERC-20 token on EVM-compatible chains (Ethereum, BNB Chain, Polygon, Arbitrum, Base, Optimism and more), such as USDT and USDC, plus USDT and native TRX on Tron.
What does it cost? (Fee-free mode)
You pay a subscription per plan — transactions are fee-free, and on-chain gas is charged at actual collection cost.

Start accepting payments today

Create a merchant account to get your credentials and run your first test payment in minutes.