Which networks can I pay out on?

USDT and USDC on Ethereum (ERC-20), BNB Chain (BEP-20) and Polygon. You choose the network and the stablecoin for every payout.

LirChain does. The network fee is part of the payout fee, so there is no gas wallet for you to keep topped up.

How do I avoid paying a user twice?

Save the withdrawal in your own database first and send its id as external_id. If a request fails or times out, check the payouts list for that id before you create another payout.

How to Send USDT Payouts to Your Users with an API

What it takes to pay users in USDT or USDC at scale, and how to send withdrawals, rewards and refunds with one API call, without a hot wallet or gas.

October 13, 2026 · 5 min read

Taking crypto in is half of a product. Sooner or later money has to go out too: a user withdraws their balance, an affiliate earns a commission, an order is refunded. This guide looks at what sending stablecoins reliably involves, and how to do it with one request.

What a payout system has to handle

A hot wallet with enough USDT or USDC in it on every network you pay on.
Gas. To send a token you need the network's own coin (ETH, BNB or POL) in the same wallet, and it runs out at the worst moment.
Order. Transactions from one wallet go out one after another, and one that gets stuck blocks every payout behind it until it is replaced with a higher fee.
Confirmations and failures. You need to know when a payout is final, and to return the money to the user's balance when it is not sent.
Not paying twice. A retry after a timeout must never become a second transfer.

The Payouts API does all five. You say where the money goes and how much, and read back the status.

Step 1: have a balance

Payouts are paid from your LirChain balance, in dollars. It fills up with the deposits and payments your customers make through deposit wallets and one-time payments, and you can add USDT or USDC to it yourself from the dashboard.

Step 2: create a payout

Create a free account, open the Payouts project in the dashboard and copy its API key. Then send the network, the stablecoin, the receiver's address and the amount. external_id is your own id for the payout, such as the id of the withdrawal in your database.

curl https://api.lirchain.com/merchant/payout/create \
  -H "x-api-key: YOUR_API_KEY" \
  -H "content-type: application/json" \
  -d '{
    "network": "polygon",
    "asset": "USDT",
    "address": "0x52aE0F1c8D4b7A90e3B6c2D15f8A47e09B3C91F3",
    "amount": "25.50",
    "external_id": "user-5521"
  }'

const API_KEY = "YOUR_API_KEY";

async function createPayout(params) {
    const response = await fetch("https://api.lirchain.com/merchant/payout/create", {
        method: "POST",
        headers: { "x-api-key": API_KEY, "content-type": "application/json" },
        body: JSON.stringify(params),
    });

    if (!response.ok) {
        throw new Error(`LirChain API ${response.status}: ${await response.text()}`);
    }

    return response.json();
}

const result = await createPayout({
    network: "polygon",
    asset: "USDT",
    address: "0x52aE0F1c8D4b7A90e3B6c2D15f8A47e09B3C91F3",
    amount: "25.50",
    external_id: "user-5521",
});

const API_KEY = "YOUR_API_KEY";

type CreatePayoutParams = {
    network: string;
    asset: string;
    address: string;
    amount: number | string;
    external_id?: string;
};

type CreatePayoutResult = {
    id: string;
    external_id: string | null;
    network: string;
    asset: string;
    address: string;
    amount: string;
    fee: string;
    receive_amount: string;
    pay_amount: string;
    status: string;
    tx_hash: string | null;
    created_ms: number;
    processed_ms: number | null;
};

async function createPayout(params: CreatePayoutParams): Promise<CreatePayoutResult> {
    const response = await fetch("https://api.lirchain.com/merchant/payout/create", {
        method: "POST",
        headers: { "x-api-key": API_KEY, "content-type": "application/json" },
        body: JSON.stringify(params),
    });

    if (!response.ok) {
        throw new Error(`LirChain API ${response.status}: ${await response.text()}`);
    }

    return response.json();
}

const result = await createPayout({
    network: "polygon",
    asset: "USDT",
    address: "0x52aE0F1c8D4b7A90e3B6c2D15f8A47e09B3C91F3",
    amount: "25.50",
    external_id: "user-5521",
});

import requests

API_KEY = "YOUR_API_KEY"


def create_payout(**params):
    response = requests.post(
        "https://api.lirchain.com/merchant/payout/create",
        headers={"x-api-key": API_KEY},
        json=params,
        timeout=30,
    )
    response.raise_for_status()
    return response.json()


result = create_payout(
    network="polygon",
    asset="USDT",
    address="0x52aE0F1c8D4b7A90e3B6c2D15f8A47e09B3C91F3",
    amount="25.50",
    external_id="user-5521",
)

<?php

const API_KEY = "YOUR_API_KEY";

function create_payout(array $params): array
{
    $curl = curl_init("https://api.lirchain.com/merchant/payout/create");

    curl_setopt_array($curl, [
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_POST => true,
        CURLOPT_POSTFIELDS => json_encode($params),
        CURLOPT_HTTPHEADER => ["x-api-key: " . API_KEY, "content-type: application/json"],
    ]);

    $body = curl_exec($curl);
    $status = curl_getinfo($curl, CURLINFO_HTTP_CODE);

    if ($body === false || $status >= 400) {
        throw new Exception("LirChain API $status: $body");
    }

    return json_decode($body, true);
}

$result = create_payout([
    "network" => "polygon",
    "asset" => "USDT",
    "address" => "0x52aE0F1c8D4b7A90e3B6c2D15f8A47e09B3C91F3",
    "amount" => "25.50",
    "external_id" => "user-5521",
]);

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
)

const apiKey = "YOUR_API_KEY"

func CreatePayout(params map[string]any) (map[string]any, error) {
	body, err := json.Marshal(params)
	if err != nil {
		return nil, err
	}

	request, err := http.NewRequest("POST", "https://api.lirchain.com/merchant/payout/create", bytes.NewReader(body))
	if err != nil {
		return nil, err
	}
	request.Header.Set("x-api-key", apiKey)
	request.Header.Set("content-type", "application/json")

	response, err := http.DefaultClient.Do(request)
	if err != nil {
		return nil, err
	}
	defer response.Body.Close()

	data, err := io.ReadAll(response.Body)
	if err != nil {
		return nil, err
	}
	if response.StatusCode >= 400 {
		return nil, fmt.Errorf("LirChain API %d: %s", response.StatusCode, data)
	}

	var result map[string]any
	return result, json.Unmarshal(data, &result)
}

func main() {
	result, err := CreatePayout(map[string]any{
		"network": "polygon",
		"asset": "USDT",
		"address": "0x52aE0F1c8D4b7A90e3B6c2D15f8A47e09B3C91F3",
		"amount": "25.50",
		"external_id": "user-5521",
	})
	fmt.Println(result, err)
}

The amount is in dollars, at least $1, with at most two decimals. The fee is taken on top: receive_amount is what the receiver gets, and pay_amount is what leaves your balance. Both are taken the moment the payout is created, so you can never send more than you have. If the balance is too low the answer is 402 and nothing happens.

A payout cannot be cancelled once it is created. Check the address and the network with the user before you send the request.

Step 3: follow the status

A payout is pending, then processing once it is sent (a few seconds after it is created), then completed when the network has safely confirmed it, 12 blocks later. Read it to see where it is and to get the transaction hash to show your user:

curl "https://api.lirchain.com/merchant/payout/payout?id=8a1f4c2e-6d3b-4f70-9c15-2e7b0a94d6c3" \
  -H "x-api-key: YOUR_API_KEY"

const API_KEY = "YOUR_API_KEY";

async function getPayout(params) {
    const query = new URLSearchParams(params);
    const response = await fetch(`https://api.lirchain.com/merchant/payout/payout?${query}`, {
        headers: { "x-api-key": API_KEY },
    });

    if (!response.ok) {
        throw new Error(`LirChain API ${response.status}: ${await response.text()}`);
    }

    return response.json();
}

const result = await getPayout({
    id: "8a1f4c2e-6d3b-4f70-9c15-2e7b0a94d6c3",
});

const API_KEY = "YOUR_API_KEY";

type GetPayoutParams = {
    id: string;
};

type GetPayoutResult = {
    id: string;
    external_id: string | null;
    network: string;
    asset: string;
    address: string;
    amount: string;
    fee: string;
    receive_amount: string;
    pay_amount: string;
    status: string;
    tx_hash: string | null;
    created_ms: number;
    processed_ms: number | null;
};

async function getPayout(params: GetPayoutParams): Promise<GetPayoutResult> {
    const query = new URLSearchParams(Object.entries(params).map(([name, value]) => [name, String(value)]));
    const response = await fetch(`https://api.lirchain.com/merchant/payout/payout?${query}`, {
        headers: { "x-api-key": API_KEY },
    });

    if (!response.ok) {
        throw new Error(`LirChain API ${response.status}: ${await response.text()}`);
    }

    return response.json();
}

const result = await getPayout({
    id: "8a1f4c2e-6d3b-4f70-9c15-2e7b0a94d6c3",
});

import requests

API_KEY = "YOUR_API_KEY"


def get_payout(**params):
    response = requests.get(
        "https://api.lirchain.com/merchant/payout/payout",
        headers={"x-api-key": API_KEY},
        params=params,
        timeout=30,
    )
    response.raise_for_status()
    return response.json()


result = get_payout(
    id="8a1f4c2e-6d3b-4f70-9c15-2e7b0a94d6c3",
)

<?php

const API_KEY = "YOUR_API_KEY";

function get_payout(array $params): array
{
    $curl = curl_init("https://api.lirchain.com/merchant/payout/payout?" . http_build_query($params));

    curl_setopt_array($curl, [
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_HTTPHEADER => ["x-api-key: " . API_KEY],
    ]);

    $body = curl_exec($curl);
    $status = curl_getinfo($curl, CURLINFO_HTTP_CODE);

    if ($body === false || $status >= 400) {
        throw new Exception("LirChain API $status: $body");
    }

    return json_decode($body, true);
}

$result = get_payout([
    "id" => "8a1f4c2e-6d3b-4f70-9c15-2e7b0a94d6c3",
]);

package main

import (
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"net/url"
)

const apiKey = "YOUR_API_KEY"

func GetPayout(params url.Values) (map[string]any, error) {
	request, err := http.NewRequest("GET", "https://api.lirchain.com/merchant/payout/payout?"+params.Encode(), nil)
	if err != nil {
		return nil, err
	}
	request.Header.Set("x-api-key", apiKey)

	response, err := http.DefaultClient.Do(request)
	if err != nil {
		return nil, err
	}
	defer response.Body.Close()

	data, err := io.ReadAll(response.Body)
	if err != nil {
		return nil, err
	}
	if response.StatusCode >= 400 {
		return nil, fmt.Errorf("LirChain API %d: %s", response.StatusCode, data)
	}

	var result map[string]any
	return result, json.Unmarshal(data, &result)
}

func main() {
	result, err := GetPayout(url.Values{
		"id": {"8a1f4c2e-6d3b-4f70-9c15-2e7b0a94d6c3"},
	})
	fmt.Println(result, err)
}

A payout that could not be sent becomes failed, and its amount and fee are back on your balance. Poll a payout every few seconds until it is completed or failed, then stop.

A safe withdrawal flow

The user asks to withdraw. In one database transaction, take the amount from their balance in your system and save a withdrawal with a new id.
Create the payout with that id as external_id. If the request times out, look the payout up in the payouts list before trying again, so a retry cannot pay twice.
Poll the payout. On completed, mark the withdrawal done and show the transaction hash. On failed, give the amount back to the user.

What it costs

A payout costs the percentage of your plan, from 1% on Free down to 0.25% on Enterprise, at least $0.10.
The network gas is included. You never hold ETH, BNB or POL.
Every plan, including Free, sends unlimited payouts.

Questions and answers

Which networks can I pay out on?: USDT and USDC on Ethereum (ERC-20), BNB Chain (BEP-20) and Polygon. You choose the network and the stablecoin for every payout.
Who pays the gas?: LirChain does. The network fee is part of the payout fee, so there is no gas wallet for you to keep topped up.
How do I avoid paying a user twice?: Save the withdrawal in your own database first and send its id as external_id. If a request fails or times out, check the payouts list for that id before you create another payout.

Try it on the Free plan

Every product is included, and no card is needed to sign up.

Create a free account