gowpay.net
API v1

Documentation

Accept USDT (TRC-20) on your site in three steps - no SDK, no agent, no developer required for the basic setup. The gateway watches the TRON blockchain and tells you when money arrived.

Quick start - 3 steps

Step 1. Take your public key

Dashboard - Integration - "Your API keys" (or API Keys if you need the secret: it is shown once at creation).

pk = pwm90FZXkR23uisHynJytmBPYi48FRdGV1QoJrwhz3UJEA9M8CVH8sLika0beNAE

Step 2. Paste the widget snippet on your site

The snippet creates the payment when the customer clicks and opens the checkout in a modal. The button below is inserted automatically in the bottom-left corner; you can also intercept your own button.

<!-- one line: any site, any amount -->
<script src="https://gowpay.net/widget/pay.js"
        data-api-key="YOUR_PUBLIC_KEY"
        data-amount="2.99"></script>

<!-- cabinet / checkout page: no floating button, your own button -->
<script src="https://gowpay.net/widget/pay.js"
        data-api-key="YOUR_PUBLIC_KEY"
        data-custom-amount="true" data-min="10" data-max="100000"
        data-auto-button="false"></script>

<button type="button" data-usdt-gate="auto"
        data-reference="YOUR_UNIQUE_ORDER_ID">Top up balance</button>

Cabinet mode: add data-auto-button="false" to the script and place a [data-usdt-gate] button where you need it (deposit page, checkout, cabinet). Replace YOUR_UNIQUE_ORDER_ID with a unique order/reference per payment — use it in the webhook to credit the right user. Or use a ready fixed-amount button from the dashboard ("Block A" snippet) that points at one checkout link.

Step 3. Set a webhook URL

Dashboard - Integration - "Webhook URL": we POST JSON there on every event (payment.confirmed, payment.overpaid, payment.late, payment.expired, withdrawal.sent, ...). Signing is described below.

Create a payment (server-to-server)

curl -X POST https://gowpay.net/api/v1/payments \
  -H "X-Api-Key: $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"amount":"2.99","currency":"USDT","network":"TRC20","reference_id":"order-1234"}'

Response contains reference_id, amount_usdt, expires_at and checkout_url - redirect the customer there. Repeating the same reference_id returns the same payment (idempotency).

Checkout page

The hosted checkout shows a tron: QR code, the exact amount, the deposit address and live status (polled every 15 seconds). It is embeddable in an iframe (the widget does that automatically) and shows a "Secured by gowpay.net" footer.

Status

GET https://gowpay.net/api/v1/payments/{reference_id}/status
X-Api-Key: YOUR_PUBLIC_KEY

Returns the current status: pending, detected, confirming, confirmed, overpaid, expired.

Webhooks & signature

Every delivery is a JSON POST with headers X-Signature = HMAC-SHA256 hex of the raw request body, keyed with your secret, and X-Signature-Version (v2 = API-key secret, v1 = merchant secret). Always verify against the raw body, not a re-encoded array.

Payload example

{
  "event": "payment.confirmed",
  "event_id": "0b0f6f3a-...",
  "payment_id": 123,
  "reference_id": "order-1234",
  "amount_usdt": "2.990000",
  "status": "confirmed",
  "address": "T...",
  "transaction_hash": "1051c12f...",
  "created_at": "2026-11-07T10:00:00+00:00",
  "confirmed_at": "2026-11-07T10:02:11+00:00",
  "is_late_payment": false,
  "signature_version": "v2"
}

PHP (Laravel route)

Route::post('/webhook/gowpay', function (Request $request) {
    $raw = $request->getContent();                 // raw body, do not use ->all()
    $expected = hash_hmac('sha256', $raw, config('services.gowpay.secret'));

    if (!hash_equals($expected, (string) $request->header('X-Signature'))) {
        abort(401, 'Bad signature');
    }

    $event = json_decode($raw, true);
    if (($event['event'] ?? null) === 'payment.confirmed') {
        // mark order paid: $event['reference_id'], $event['amount_usdt']
    }

    return response()->json(['ok' => true]);
});

Node.js (Express)

const crypto = require('crypto');

app.post('/webhook/gowpay', express.raw({ type: 'application/json' }), (req, res) => {
  const raw = req.body;                                   // Buffer with the exact bytes
  const expected = crypto.createHmac('sha256', process.env.GOWPAY_SECRET).update(raw).digest('hex');
  const got = req.get('X-Signature') || '';

  if (expected.length !== got.length || !crypto.timingSafeEqual(Buffer.from(expected), Buffer.from(got))) {
    return res.status(401).send('bad signature');
  }

  const event = JSON.parse(raw.toString('utf8'));
  if (event.event === 'payment.confirmed') { /* mark order paid */ }
  res.json({ ok: true });
});

Python (Flask)

import hashlib, hmac, os
from flask import Flask, request, abort

app = Flask(__name__)

@app.post('/webhook/gowpay')
def webhook():
    raw = request.get_data()                                   # raw bytes
    expected = hmac.new(os.environ['GOWPAY_SECRET'].encode(), raw, hashlib.sha256).hexdigest()
    if not hmac.compare_digest(expected, request.headers.get('X-Signature', '')):
        abort(401)

    event = request.get_json(force=True)
    if event.get('event') == 'payment.confirmed':
        ...  # mark order paid
    return {'ok': True}

Errors

Test mode

Test keys (pk_test_...) are not available yet: payments are created against the live TRON wallet, so a test payment must be a real on-chain transfer. Until test mode ships, we recommend verifying the integration with a 1 USDT payment - it credits your balance like any other. Sandbox mode is on the roadmap: a separate test key that returns fake checkouts and never touches the blockchain.

Security

Start free