Crypto Payments for AI Agents

Enable your AI agents to send and receive stablecoin payments autonomously using XPayLabs. Non-custodial, self-hosted payment infrastructure for agentic workflows.

AI agents increasingly need to transact in digital value — paying for compute, purchasing API credits, settling with other agents, or receiving micropayments from users. XPayLabs provides the infrastructure for agents to hold and transfer stablecoins autonomously, without a third-party custodian.

Why Crypto for AI Agents?

Challenge	XPayLabs Solution
Agents need programmable money	REST API for createCollection / createPayout — agents call endpoints directly
No human in the loop for approvals	Automated signing with environment-stored secrets
Cross-border agent-to-agent payments	Stablecoins on TRON, EVM, and SUI settle in seconds
Microtransactions	Zero gateway fees — only blockchain gas costs ($0.01–$0.50)
Self-custody required	Non-custodial — keys stay in your Docker containers

Agent Payment Flows

Incoming Payments (Agent Gets Paid)

An agent receives crypto payments by creating collection orders. This is the most common flow — users or other agents send funds to a deposit address generated by the agent.

// AI agent creates a payment request
async function requestPayment(userId: string, amount: number, orderId: string) {
  const collection = await xpay.createCollection({
    amount,
    symbol: 'USDT',
    chain: 'TRON',
    orderId,
    uid: userId,
  });

  return {
    depositAddress: collection.data.address,
    expiresAt: collection.data.expiredTime,
    checkoutUrl: collection.data.paymentUrl,
  };
}

The agent then listens for the ORDER_SUCCESS webhook to release the service:

// Webhook handler for the agent
app.post('/webhook', (req, res) => {
  const event = xpay.parseWebhook(JSON.stringify(req.body), req.body.sign, req.body.timestamp.toString());

  if (event?.notifyType === 'ORDER_SUCCESS') {
    const data = event.data as any;
    // Release API credits, unlock features, or start a job
    await unlockService(data.orderId, data.actualAmount);
  }

  res.status(200).send('ok');
});

Outgoing Payments (Agent Pays Out)

An agent initiates payouts to external addresses — paying for compute, staking, or settling with other agents:

// Agent pays for compute resources
async function payComputeProvider(providerAddress: string, amount: number, jobId: string) {
  const payout = await xpay.createPayout({
    amount,
    symbol: 'USDT',
    chain: 'ETH',
    orderId: `compute-${jobId}`,
    receiveAddress: providerAddress,
    uid: 'ai-agent-01',
  });

  return payout.data.orderId;
}

Agent-to-Agent Payments

Two autonomous agents can transact directly:

Agent A  ──POST /v1/order/createCollection──▶  Gateway  ──returns deposit address──▶  Agent A
                                                                                           │
                                                                                           │ sends deposit address to Agent B
                                                                                           ▼
Agent B  ──sends USDT to address─────────────▶  Blockchain  ──scanner detects──▶  Gateway
                                                                                           │
                                                                                           │ ORDER_SUCCESS webhook
                                                                                           ▼
Agent A  ──receives webhook──▶  fulfills agreement

Autonomous Agent Architecture

┌─────────────────────────────────────────────────┐
│                  Your Server                     │
│                                                   │
│  ┌──────────┐     ┌─────────────┐               │
│  │  Agent A  │────▶│ XPayLabs    │               │
│  │ (buyer)   │◀───│ SDK / API   │               │
│  └──────────┘     └──────┬──────┘               │
│                          │                       │
│  ┌──────────┐            │   ┌───────────────┐  │
│  │  Agent B  │───────────┘   │  Webhook      │  │
│  │ (seller)  │───────────────│  Endpoint     │  │
│  └──────────┘               └───────────────┘  │
│                          │                       │
│                   ┌──────▼──────┐               │
│                   │  Blockchain │               │
│                   │  Scanner    │               │
│                   └─────────────┘               │
└─────────────────────────────────────────────────┘

Key Design Considerations

Secret Management

The merchant token and API secret must be accessible to the agent at runtime without hardcoding:

# Environment variables — never commit to git
XPAYLABS_MERCHANT_TOKEN=your-merchant-token
XPAYLABS_API_SECRET=your-api-secret
XPAYLABS_GATEWAY_URL=http://gateway:3010

Idempotency

Agents may retry failed requests. Use the orderId field as an idempotency key — the same orderId on a createCollection or createPayout call returns the existing order instead of creating a duplicate.

Webhook Reliability

Agents should use the polling fallback (getOrderStatus) if webhooks are missed. Poll every 3 seconds until SUCCESS, EXPIRED, or FAILED:

async function waitForConfirmation(orderId: string, maxWaitMs = 120000): Promise<boolean> {
  const start = Date.now();

  while (Date.now() - start < maxWaitMs) {
    const status = await xpay.getOrderStatus(orderId);
    const s = status.data?.status;

    if (s === 'SUCCESS') return true;
    if (s === 'EXPIRED' || s === 'FAILED') return false;

    await new Promise(r => setTimeout(r, 3000));
  }

  return false; // timeout
}

Balance Management

Before creating payouts, check the gateway’s hot wallet balance:

const balance = await xpay.getMerchantBalance('USDT');
console.log(`Available: ${balance.data?.balance}, Frozen: ${balance.data?.frozenBalance}`);

For EVM chains, also ensure the hot wallet has sufficient native gas tokens (ETH, BNB, MATIC, AVAX) to cover transaction fees.

Use Cases

Use Case	Flow	Example
API access pay-per-call	Agent creates collection → user pays → webhook unlocks endpoint	LLM inference API
Compute marketplace	Agent A pays Agent B for GPU time via payout	Distributed ML training
Autonomous affiliate	Affiliate agent receives collection webhook, splits payout to referrer	Referral program
Agent-to-agent settlement	Periodic batch payouts between agent wallets	Cross-agent accounting
Micropayment streaming	Frequent small collections (ticketed)	Real-time data feeds

Getting Started

1. Deploy XPayLabs via Docker Compose
2. Install the Node.js SDK or call the REST API directly
3. Configure your agent’s environment with the merchant token and API secret
4. Create a webhook endpoint for ORDER_SUCCESS events
5. Start creating collection and payout orders programmatically

For agent-to-agent payments, both agents can share the same XPayLabs gateway instance — or run separate instances with their own keys for full isolation.