Send payments

Pay anyone by identity, no wallet address needed on either side:

• Community members — Discord or Telegram handle.
• Contributors — GitHub username or email.
• Creators — X handle. TikTok and Instagram are coming.
• Collaborators, freelancers, bounty winners — email or username.
• One or many — pay one person with this endpoint, or batch up to 10 recipients in a single signature with multi-send.

Recipients don't need a wallet ready to go either. They claim straight to a wallet Loofta sets up for them on the spot, or, in Nigeria, straight to a bank account instead.

POST /payouts pays a recipient — by email, username, or social handle — from the API key owner's own account. The counterpart to payment links: that one gets you paid, this one pays someone else. Self-custody — it returns an unsigned transaction, you sign it with your own wallet. Loofta never holds or moves your funds on your behalf.

Try it — pay someone now

Live (mainnet) — this sends a real, small payout from your own account. Pay now calls POST /payouts with your API key; on Solana it signs the returned transaction with your own Loofta wallet right here and broadcasts it, the same round trip a real integration makes. If you leave it unsettled — never signed, or never funded at the deposit address — it auto-expires after 4 hours.

Don't have a key yet? Generate one.

Request

curl -X POST https://api.loofta.xyz/payouts \
  -H "Authorization: Bearer lft_live_..." \
  -H "Content-Type: application/json" \
  -d '{
    "amount": 25,
    "recipient_type": "email",
    "recipient_identifier": "alice@example.com",
    "sender_wallet": "5dCT...BKuq",
    "message": "August payout"
  }'

A payout that never gets funded auto-expires — unsigned_transaction never signed and broadcast expires 4 hours after creation; nothing ever sent to a deposit_address expires whenever that deposit address's own bridge quote does (often a few days, never less than 4 hours), since the claim shouldn't die before the address stops being watched. Once expired, claim_link no longer accepts payment. A payout that has already been funded is unaffected, however long the recipient takes to claim it.

Response

{
  "payment_id": "b3f1...e02a",
  "short_id": "aB3xK9pQ",
  "claim_link": "https://pay.loofta.xyz/c/aB3xK9pQ",
  "unsigned_transaction": "AQAAAAAAAAAAAAAAAAAAAAAA...",
  "transaction_version": "legacy",
  "send_to": "base",
  "is_private": false
}

unsigned_transaction is a base64-encoded, unsigned Solana transaction — transaction_version tells you whether to deserialize it as a legacy Transaction or a VersionedTransaction (private transfers can come back as either; public ones are always legacy). send_to tells you which RPC to broadcast the signed transaction to — "base" is regular Solana; a private transfer can come back as "ephemeral", MagicBlock's own rollup RPC, instead.

Sign and broadcast

This is the one step Loofta can't do for you — sender_wallet is your own wallet, so only you can authorize spending from it. Deserialize, sign with that wallet's keypair, and send it to the RPC send_to names:

import { Connection, Transaction, VersionedTransaction, Keypair } from "@solana/web3.js";

const rpcUrl = send_to === "ephemeral"
  ? "https://mainnet-tee.magicblock.app"
  : "https://api.mainnet-beta.solana.com";
const connection = new Connection(rpcUrl);
const senderKeypair = Keypair.fromSecretKey(/* your own key, never sent to Loofta */);

const raw = Buffer.from(unsigned_transaction, "base64");
const tx = transaction_version === "v0"
  ? VersionedTransaction.deserialize(raw)
  : Transaction.from(raw);

tx.sign(senderKeypair); // VersionedTransaction: tx.sign([senderKeypair])
const signature = await connection.sendRawTransaction(tx.serialize());

The recipient sees the payout waiting for them at claim_link the moment your transaction lands — same claim/burner mechanics as every other Loofta payment, so an unregistered recipient claims by signing in with the email or handle you sent it to.

Funding from another chain

Pass funding_source instead of sender_wallet to skip the Solana transaction entirely — you'll get a deposit address to send USDT/USDC to on the chain you actually hold funds on:

curl -X POST https://api.loofta.xyz/payouts \
  -H "Authorization: Bearer lft_live_..." \
  -H "Content-Type: application/json" \
  -d '{
    "amount": 25,
    "recipient_type": "email",
    "recipient_identifier": "alice@example.com",
    "funding_source": "usdc_base",
    "refund_wallet": "0xYourBaseAddress..."
  }'

{
  "payment_id": "b3f1...e02a",
  "short_id": "aB3xK9pQ",
  "claim_link": "https://pay.loofta.xyz/c/aB3xK9pQ",
  "is_private": false,
  "funding_source": "usdc_base",
  "deposit_address": "0x9f2c...4a1b",
  "deposit_memo": null,
  "deposit_amount": "25.081234",
  "deposit_deadline": "2026-09-07T12:34:56.000Z"
}

Send exactly deposit_amount of the funding_source token to deposit_address (include deposit_memo if present) before deposit_deadline. Alice sees the payout at claim_link once the deposit is confirmed and swept — there's nothing left for you to sign or broadcast.

deposit_note (only present for usdt_ton): every TON deposit address is brand new and holds zero TON. Most wallets attach enough gas automatically when you use their normal send flow, but a jetton transfer sent with too little forward gas can land on-chain and still never register as a deposit — the confirmed failure mode is a gas-starved notification message, not a lost payment, but it needs manual recovery either way. Read this field and pass it through to whoever's actually sending the funds.