API de pagos cripto en USDT y USDC
Paga a tus usuarios, socios y vendedores en stablecoins con una sola llamada a la API. Indica una dirección y un importe y LirChain envía USDT o USDC en Ethereum, BNB Chain o Polygon desde tu saldo, y paga el gas de la red por ti.
- Una llamada a la API por pago, enviado en segundos
- USDT y USDC en Ethereum, BNB Chain y Polygon
- Pagos ilimitados en todos los planes, gas incluido
Pagos en stablecoins sin una hot wallet propia
Enviar cripto a muchas personas implica operar una hot wallet con fondos, mantener monedas para gas en cada red, ordenar transacciones, reenviar las atascadas y seguir las confirmaciones. Una API de pagos te quita todo eso: pides una transferencia y lees su estado.
Los pagos salen del mismo saldo en dólares que llenan tus wallets de depósito y tus pagos únicos, así que el dinero que pagaron tus clientes puede volver a salir como retiros, recompensas, reembolsos o liquidaciones a vendedores. También puedes recargar el saldo tú mismo en USDT o USDC.
El importe y la comisión se descuentan en el momento de crear el pago, así que nunca puedes enviar más de lo que tienes. Si un pago no se puede enviar, ambos vuelven a tu saldo.
Qué te ofrece Pagos a usuarios
Una llamada por pago
Envía una red, una stablecoin, una dirección y un importe. El pago queda creado y en camino.
Sin gas que gestionar
LirChain paga la comisión de red de cada pago. Nunca necesitas tener ETH, BNB o POL solo para poder enviar.
Enviado en segundos
Un pago se emite unos segundos después de crearse y se completa cuando la red lo confirma, con su hash de transacción.
Seguro por diseño
El importe y la comisión se reservan por adelantado, y un pago que tu saldo no cubre se rechaza antes de enviar nada.
Tu propio id en cada pago
Adjunta tu id de usuario o de pedido y recíbelo con el pago, así siempre encaja con tus registros.
API y panel
Automatiza los pagos desde tu servidor o créalos a mano en el panel cuando solo necesites unos pocos.
Cómo funciona
Del registro a la primera llamada en unos minutos.
- 1
Llena tu saldo
Tu saldo crece con cada depósito y cada pago de tus clientes. También puedes añadirle USDT o USDC desde el panel.
- 2
Crea un pago
Envía la red, USDT o USDC, la dirección del destinatario, el importe en dólares y tu propio id para él.
- 3
Sigue su estado
Un pago pasa de pendiente a en proceso y a completado. Léelo por la API para obtener el estado y el hash de la transacción.
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)
}{
"id": "8a1f4c2e-6d3b-4f70-9c15-2e7b0a94d6c3",
"external_id": "user-5521",
"network": "polygon",
"asset": "USDT",
"address": "0x52ae0f1c8d4b7a90e3b6c2d15f8a47e09b3c91f3",
"amount": "25.50",
"fee": "0.1275",
"receive_amount": "25.50",
"pay_amount": "25.6275",
"status": "pending",
"tx_hash": null,
"created_ms": 1791506100412,
"processed_ms": null
}Todos los endpoints y campos están en la referencia de la API de Pagos a usuarios (en inglés). ¿Usas un agente de programación? Dale lirchain.com/llms-full.txt y podrá escribir la integración por ti.
Redes y stablecoins para pagar
Los pagos se envían en USDT o USDC. Eliges la red y la stablecoin de cada pago.
| Red | Monedas y tokens |
|---|---|
| Ethereum | USDTUSDC |
| BNB Chain | USDTUSDC |
| Polygon | USDTUSDC |
Para qué usan los equipos Pagos a usuarios
Retiros de usuarios
Deja que los usuarios de tu exchange, juego o wallet retiren a su propia dirección directamente desde tu botón de retiro.
Recompensas de afiliados y referidos
Paga comisiones y bonos en stablecoins a medida que se ganan, a cualquier número de socios.
Liquidaciones a vendedores de marketplaces
Cobra a los compradores con wallets de depósito o pagos únicos y liquida a los vendedores desde el mismo saldo.
Reembolsos
Devuelve un pago a la dirección de un cliente con una llamada, ligado al pedido original por tu propio id.
Pagos a contratistas y socios
Paga a freelancers, proveedores y equipos remotos en USDT o USDC sin demoras bancarias ni fronteras.
Premios y cashback
Envía premios, cashback y recompensas promocionales automáticamente desde tu propio sistema.
Precios de Pagos a usuarios
Todos los planes envían pagos ilimitados. Un pago cuesta el porcentaje de tu plan además de su importe, como mínimo $0.10, y el gas de la red está incluido.
| Plan | Free | Starter | Business | Enterprise |
|---|---|---|---|---|
| Precio al mes | Gratis | $19.99 | $49.99 | $249.99 |
| Pagos a usuarios | Ilimitados | Ilimitados | Ilimitados | Ilimitados |
| Comisión por pago | 1% | 0,5% | 0,375% | 0,25% |
Cada plan incluye los cuatro productos. Comparar los planes
Pagos a usuarios: preguntas y respuestas
- ¿En qué redes y tokens puedo pagar?
- USDT y USDC en Ethereum (ERC-20), BNB Chain (BEP-20) y Polygon. Eliges la red y la stablecoin de cada pago.
- ¿Quién paga el gas de un pago?
- LirChain. La comisión de red está incluida en la comisión del pago, así que no necesitas tener ETH, BNB ni POL.
- ¿Qué tan rápido se envía un pago en cripto?
- Un pago se envía a los pocos segundos de crearse. Se marca como completado cuando la red lo ha confirmado de forma segura, 12 bloques después, y se le adjunta el hash de la transacción.
- ¿Cuánto cuesta un pago?
- El porcentaje de tu plan (1% en Free, 0,5% en Starter, 0,375% en Business, 0,25% en Enterprise), como mínimo $0.10, descontado de tu saldo además del importe. El destinatario recibe el importe completo que indicaste.
- ¿Qué pasa si un pago no se puede enviar?
- Se marca como fallido y su importe y su comisión vuelven íntegros a tu saldo.
- ¿Hay un límite en el número de pagos?
- No. Todos los planes, incluido Free, envían pagos ilimitados de $1 o más.
- ¿De dónde sale el dinero de los pagos?
- De tu saldo en LirChain, que se llena con los depósitos a tus wallets de depósito y con los pagos únicos cobrados. También puedes añadirle USDT o USDC tú mismo desde el panel.
Funciona con el resto de LirChain
Una cuenta, un saldo y una API para los cuatro productos.
Empieza gratis con Pagos a usuarios
Las cuentas nuevas empiezan en el plan Free, con todos los productos incluidos y sin tarjeta.