ZyndPay API Reference

curl https://api.zyndpay.io/v1/payments \
  -H "X-Api-Key: zyp_live_sk_..."

// 1. Install
// npm install @zyndpay/sdk

// 2. Initialize
import { ZyndPay } from '@zyndpay/sdk';

const zyndpay = new ZyndPay({
  apiKey: process.env.ZYNDPAY_API_KEY!,
  webhookSecret: process.env.ZYNDPAY_WEBHOOK_SECRET,
});

// 3. Create a pay-in and get a payment URL
const payin = await zyndpay.payins.create({
  amount: '100',
  externalRef: 'order_' + Date.now(), // your order ID
  successUrl: 'https://yoursite.com/success',
  cancelUrl: 'https://yoursite.com/cancel',
});
console.log('Redirect customer to:', payin.paymentUrl);
// Or show payin.address if you want to display the TRON address directly

// 4. Handle the webhook (Express.js)
import express from 'express';
const app = express();

app.post('/webhooks/zyndpay', express.raw({ type: 'application/json' }), (req, res) => {
  const signature = req.headers['zyndpay-signature'] as string;

  let event;
  try {
    event = zyndpay.webhooks.verify(req.body, signature);
  } catch {
    return res.status(400).send('Invalid signature');
  }

  switch (event.event) {
    case 'payin.confirmed':
      // Payment received — fulfill the order
      console.log('Paid:', event.data.externalRef, event.data.amount, 'USDT');
      break;
    case 'payin.expired':
      console.log('Expired:', event.data.externalRef);
      break;
    case 'payin.underpaid':
      console.log('Underpaid:', event.data.externalRef,
        'got', event.data.amount, 'expected', event.data.amountRequested);
      break;
  }

  res.json({ received: true });
});

// 5. Poll / check status programmatically
const tx = await zyndpay.payins.get(payin.transactionId);
console.log('Status:', tx.status); // "CONFIRMED"

curl -X POST https://api.zyndpay.io/v1/payments \
  -H "X-Api-Key: zyp_live_sk_..." \
  -H "Content-Type: application/json" \
  -d '{
    "amount": "100.00",
    "externalRef": "order_123",
    "expiresInSeconds": 3600,
    "successUrl": "https://yoursite.com/payment/success",
    "cancelUrl": "https://yoursite.com/payment/cancel"
  }'

{
  "success": true,
  "data": {
    "transactionId": "pay_abc123...",
    "address": "TRXabc123def456ghi789jkl",
    "paymentUrl": "https://checkout.zyndpay.io/pay_abc123...",
    "qrCodeUrl": "data:image/png;base64,iVBOR...",
    "amount": "100.00",
    "amountExpected": "101.00",
    "networkFee": "1",
    "currency": "USDT_TRC20",
    "chain": "TRON",
    "status": "AWAITING_PAYMENT",
    "expiresAt": "2026-03-06T12:00:00.000Z"
  }
}

curl -X POST https://api.zyndpay.io/v1/payments \
  -H "X-Api-Key: zyp_live_sk_..." \
  -H "Content-Type: application/json" \
  -d '{
    "amount": "1000",
    "paymentMethod": "MOBILE_MONEY",
    "customerPhone": "+22670123456",
    "customerName": "Aïcha Traoré",
    "operatorCode": "ORANGE_BF",
    "externalRef": "order_123"
  }'

{
  "success": true,
  "data": {
    "transactionId": "pay_momo_abc123",
    "paymentMethod": "MOBILE_MONEY",
    "hostedPaymentUrl": "https://checkout.zyndpay.io/m/pay_momo_abc123",
    "nextStep": "otp",
    "operatorCode": "ORANGE_BF",
    "instruction": {
      "fr": "Vous allez recevoir un SMS avec votre code de validation. Saisissez-le ci-dessous.",
      "en": "You will receive an SMS with your validation code. Enter it below."
    },
    "amount": "1000",
    "currency": "XOF",
    "status": "AWAITING_PAYMENT",
    "expiresAt": "2026-03-06T12:05:00.000Z"
  }
}

{
  "success": true,
  "data": {
    "transactionId": "pay_momo_xyz456",
    "paymentMethod": "MOBILE_MONEY",
    "hostedPaymentUrl": "https://checkout.zyndpay.io/m/pay_momo_xyz456",
    "nextStep": "approval",
    "operatorCode": "MOOV_BF",
    "instruction": {
      "fr": "Composez *555*6# sur votre téléphone pour valider le paiement.",
      "en": "Dial *555*6# on your phone to approve the payment."
    },
    "amount": "1000",
    "currency": "XOF",
    "status": "AWAITING_PAYMENT",
    "expiresAt": "2026-03-06T12:03:00.000Z"
  }
}

curl -X POST https://api.zyndpay.io/v1/payins/pay_momo_abc123/submit-otp \
  -H "X-Api-Key: zyp_live_sk_..." \
  -H "Content-Type: application/json" \
  -d '{
    "otp": "123456"
  }'

{
  "success": true,
  "data": {
    "transactionId": "pay_momo_abc123",
    "status": "AWAITING_PAYMENT"
  }
}

{
  "success": true,
  "data": {
    "id": "f4b2cb0f-08ce-4408-88d4-0a678ca0aae2",
    "address": "TRXabc123def456ghi789jkl",
    "amount": "100",
    "amountReceived": "100.00",
    "zyndpayFee": "1.00",
    "status": "CONFIRMED",
    "txHash": "abc123def456...",
    "externalRef": "order_123",
    "currency": "USDT_TRC20",
    "chain": "TRON",
    "paymentUrl": "https://checkout.zyndpay.io/f4b2cb0f...",
    "isSandbox": false,
    "createdAt": "2026-03-06T11:00:00.000Z",
    "updatedAt": "2026-03-06T11:01:02.000Z"
  }
}

curl -X POST https://api.zyndpay.io/v1/payments \
  -H "X-Api-Key: zyp_live_sk_..." \
  -H "Content-Type: application/json" \
  -d '{
    "amount": "5000",
    "paymentMethod": "CARD",
    "customerName": "Kofi Mensah",
    "customerEmail": "[email protected]",
    "externalRef": "order_abc123"
  }'

const payin = await zyndpay.payins.create({
  amount: '5000',
  paymentMethod: 'CARD',
  customerName: 'Kofi Mensah',
  customerEmail: '[email protected]',
  externalRef: 'order_abc123',
});
// Redirect customer to complete payment
window.location.href = payin.hostedPaymentUrl;

curl https://api.zyndpay.io/v1/payments/TXN_ID \
  -H "X-Api-Key: YOUR_API_KEY"

curl https://api.zyndpay.io/v1/payments \
  -H "X-Api-Key: YOUR_API_KEY"

payins = client.payins.list(limit=20, status="CONFIRMED")
for p in payins["items"]:
    print(p["transactionId"], p["status"])

{
  "success": true,
  "data": {
    "items": [ ... ],
    "meta": {
      "page": 1,
      "limit": 20,
      "total": 134,
      "totalPages": 7,
      "hasNext": true,
      "hasPrev": false
    }
  }
}

import zyndpay

client = zyndpay.ZyndPay(api_key="YOUR_API_KEY")

payin = client.payins.create(
    amount="25.00",
    external_ref="order_123",
    sandbox=True,  # remove in production
)
print(payin["transactionId"])
print(payin["paymentUrl"])

<?php
require 'vendor/autoload.php';

use ZyndPay\ZyndPay;

$client = new ZyndPay('YOUR_API_KEY');

$payin = $client->payins->create([
    'amount' => '25.00',
    'externalRef' => 'order_123',
], sandbox: true);  // remove sandbox in production

echo $payin['transactionId'];
echo $payin['paymentUrl'];

curl -X POST https://api.zyndpay.io/v1/paylinks \
  -H "X-Api-Key: zyp_live_sk_..." \
  -H "Content-Type: application/json" \
  -d '{
    "type": "FIXED",
    "products": [
      {
        "name": "Premium Course",
        "price": "49.99",
        "productType": "DIGITAL",
        "digitalUrl": "https://drive.google.com/file/d/abc123"
      }
    ],
    "collectEmail": "REQUIRED",
    "brandColor": "#635BFF"
  }'

{
  "success": true,
  "data": {
    "id": "pl_cma1xyz8f0001yx5k",
    "slug": "aB3dE6fG7hI9",
    "name": "Summer collection 2026",
    "type": "FIXED",
    "status": "ACTIVE",
    "currency": "USDT_TRC20",
    "paymentUrl": "https://dashboard.zyndpay.io/pay/link/aB3dE6fG7hI9",
    "products": [
      {
        "id": "prod_abc123",
        "name": "Premium Course",
        "description": "Lifetime access. PDF + video bundle.",
        "price": "49.990000000000000000",
        "productType": "DIGITAL",
        "digitalUrl": "https://drive.google.com/file/d/abc123",
        "imageKey": null,
        "imageUrl": null,
        "stockEnabled": false,
        "stockQty": 0,
        "lowStockThreshold": 0,
        "sortOrder": 0
      }
    ],
    "promoCodes": [],
    "useCount": 0,
    "maxUses": null,
    "ordersCount": 0,
    "expiresAt": null,
    "autoDisableOnDepletion": false,
    "collectEmail": "REQUIRED",
    "collectName": "OPTIONAL",
    "collectPhone": "OPTIONAL",
    "collectAddress": "HIDDEN",
    "recurringInterval": null,
    "recurringIntervalCount": null,
    "brandColor": null,
    "logoUrl": null,
    "coverImageKey": null,
    "coverImageUrl": null,
    "postPaymentAction": null,
    "cancelUrl": null,
    "createdAt": "2026-03-08T10:00:00.000Z",
    "updatedAt": "2026-03-08T10:00:00.000Z"
  }
}

{
  "success": true,
  "data": {
    "id": "pl_cma1xyz8f0001yx5k",
    "slug": "aB3dE6fG7hI9",
    "name": "Summer collection 2026",
    "type": "FIXED",
    "status": "ACTIVE",
    "currency": "USDT_TRC20",
    "paymentUrl": "https://dashboard.zyndpay.io/pay/link/aB3dE6fG7hI9",
    "products": [
      {
        "id": "prod_abc123",
        "name": "Premium Course",
        "description": "Lifetime access. PDF + video bundle.",
        "price": "49.990000000000000000",
        "productType": "DIGITAL",
        "digitalUrl": "https://drive.google.com/file/d/abc123",
        "imageKey": null,
        "imageUrl": null,
        "stockEnabled": false,
        "stockQty": 0,
        "lowStockThreshold": 0,
        "sortOrder": 0
      }
    ],
    "promoCodes": [],
    "useCount": 0,
    "maxUses": null,
    "ordersCount": 0,
    "expiresAt": null,
    "autoDisableOnDepletion": false,
    "collectEmail": "REQUIRED",
    "collectName": "OPTIONAL",
    "collectPhone": "OPTIONAL",
    "collectAddress": "HIDDEN",
    "recurringInterval": null,
    "recurringIntervalCount": null,
    "brandColor": null,
    "logoUrl": null,
    "coverImageKey": null,
    "coverImageUrl": null,
    "postPaymentAction": null,
    "cancelUrl": null,
    "createdAt": "2026-03-08T10:00:00.000Z",
    "updatedAt": "2026-03-08T10:00:00.000Z"
  }
}

{
  "success": true,
  "data": {
    "items": [ ... ],
    "meta": {
      "page": 1,
      "limit": 20,
      "total": 134,
      "totalPages": 7,
      "hasNext": true,
      "hasPrev": false
    }
  }
}

curl -X POST https://api.zyndpay.io/v1/pay/link/aB3dE6fG7hI9/checkout \
  -H "Content-Type: application/json" \
  -d '{
    "items": [
      { "productId": "prod_abc123", "quantity": 1 }
    ],
    "customerEmail": "[email protected]",
    "customerName": "John Doe"
  }'

{
  "success": true,
  "data": {
    "orderId": "ord_xyz789",
    "transactionId": "cma2abc9g0002yz6l0def",
    "address": "TRXabc123def456ghi789jkl",
    "amount": "49.99",
    "expiresAt": "2026-03-08T11:00:00.000Z"
  }
}

paylink = client.paylinks.create(
    products=[{"name": "Premium Plan", "price": "49.99", "productType": "DIGITAL"}],
    type="FIXED",
    collect_email="REQUIRED",
    sandbox=True,  # remove in production
)
print(paylink["id"])
print(paylink["slug"])

$paylink = $client->paylinks->create([
    'products' => [[
        'name' => 'Premium Plan',
        'price' => '49.99',
        'productType' => 'DIGITAL',
    ]],
    'type' => 'FIXED',
    'collectEmail' => 'REQUIRED',
], sandbox: true);  // remove in production

echo $paylink['id'];
echo $paylink['slug'];

curl -X POST "https://api.zyndpay.io/v1/paylinks/simulate?sandbox=true" \
  -H "X-Api-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"amount": "25.00", "methods": ["USDT_TRC20"], "currency": "USDT_TRC20", "feeBearer": "CLIENT"}'

curl https://api.zyndpay.io/v1/paylinks/PAYLINK_ID/stats \
  -H "X-Api-Key: YOUR_API_KEY"

curl https://api.zyndpay.io/v1/paylinks/PAYLINK_ID/orders \
  -H "X-Api-Key: YOUR_API_KEY"

curl -X POST https://api.zyndpay.io/v1/paylinks/PAYLINK_ID/promo-codes \
  -H "X-Api-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "code": "TABASKI",
    "discountType": "PERCENT",
    "discountValue": "15",
    "maxUses": 100,
    "expiresAt": "2026-07-07T23:59:59.000Z"
  }'

# Public endpoint — call from the cart UI on promo-input blur.
curl -X POST https://api.zyndpay.io/v1/pay/link/PAYLINK_SLUG/apply-promo \
  -H "Content-Type: application/json" \
  -d '{"code": "TABASKI"}'

{
  "success": false,
  "error": {
    "code": "PROMO_CODE_EXPIRED",
    "message": "This promo code has expired."
  },
  "statusCode": 400
}

curl -X POST https://api.zyndpay.io/v1/paylinks/templates \
  -H "X-Api-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "My Template",
    "config": {
      "type": "FIXED",
      "products": [{"name": "Product", "price": "10.00", "productType": "DIGITAL"}],
      "collectEmail": "HIDDEN"
    }
  }'

curl -X POST https://api.zyndpay.io/v1/payout \
  -H "X-Api-Key: zyp_live_sk_..." \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: a1b2c3d4-e5f6-7890-abcd-ef1234567890" \
  -d '{
    "amount": "50.00",
    "destinationAddress": "TXYZabc123def456ghi789jkl012mno345",
    "externalRef": "payout_vendor_456"
  }'

{
  "success": true,
  "data": {
    "transactionId": "cma2abc9g0002yz6l0def5678",
    "status": "PROCESSING",
    "processingFee": "1.50",
    "requiresManualApproval": false,
    "currentPayinFee": "1%",
    "currentTier": "flat"
  }
}

curl -X POST https://api.zyndpay.io/v1/payout/estimate \
  -H "X-Api-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"amount": "100.00", "destinationAddress": "TRON_ADDRESS"}'

const estimate = await zyndpay.payouts.estimate({
  amount: '100.00',
  currency: 'USDT_TRC20',
  chain: 'TRON',
  destinationAddress: 'TXyz1234567890abcdef1234567890abcde',
});
console.log(`Fee: ${estimate.fee} USDT`);
console.log(`Total deducted: ${estimate.totalDebited} USDT`);
console.log(`Sufficient balance: ${estimate.sufficient}`);

estimate = client.payouts.estimate(
    amount="100.00",
    destination_address="TRON_ADDRESS",
)
print(f"Fee: {estimate['fee']} USDT")
print(f"Total debited: {estimate['totalDebited']} USDT")

$estimate = $client->payouts->estimate([
    'amount' => '100.00',
    'destinationAddress' => 'TRON_ADDRESS',
]);

echo "Fee: " . $estimate['fee'] . " USDT\n";
echo "Total: " . $estimate['totalDebited'] . " USDT\n";

payout = client.payouts.create(
    amount="100.00",
    destination_address="TRON_ADDRESS",
    idempotency_key="payout_vendor_apr_001",
)
print(payout["id"], payout["status"])

$payout = $client->payouts->create([
    'amount' => '100.00',
    'destinationAddress' => 'TRON_ADDRESS',
], idempotencyKey: 'payout_vendor_apr_001');

echo $payout['id'];

{
  "success": true,
  "data": {
    "transactionId": "cma2abc9g0002yz6l0def5678",
    "status": "PROCESSING",
    "processingFee": "1.50",
    "requiresManualApproval": false,
    "currentPayinFee": "1%",
    "currentTier": "flat"
  }
}

{
  "success": true,
  "data": {
    "items": [ ... ],
    "meta": {
      "page": 1,
      "limit": 20,
      "total": 42,
      "totalPages": 3,
      "hasNext": true,
      "hasPrev": false
    }
  }
}

curl -X POST https://api.zyndpay.io/v1/withdrawals \
  -H "X-Api-Key: zyp_live_sk_..." \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: a1b2c3d4-e5f6-7890-abcd-ef1234567890" \
  -d '{
    "amount": "500.00",
    "whitelistAddressId": "d2f64e1f-3c3f-4c8b-bc21-1037682d691c"
  }'

{
  "success": true,
  "data": {
    "id": "wdr_cma1xyz8f0001yx5k",
    "amount": "500.00",
    "fee": "5.00",
    "netAmount": "495.00",
    "destinationAddress": "TRXabc123def456ghi789jkl",
    "status": "PENDING_REVIEW",
    "createdAt": "2026-03-06T11:00:00.000Z"
  }
}

curl https://api.zyndpay.io/v1/withdrawals \
  -H "X-Api-Key: YOUR_API_KEY"

withdrawal = client.withdrawals.create(
    amount="50.00",
    idempotency_key="withdrawal_001",
)
print(withdrawal["id"], withdrawal["status"])

curl https://api.zyndpay.io/v1/withdrawals/WD_ID \
  -H "X-Api-Key: YOUR_API_KEY"

{
  "success": true,
  "data": {
    "id": "wdr_cma1xyz8f0001yx5k",
    "amount": "500.00",
    "fee": "5.00",
    "netAmount": "495.00",
    "destinationAddress": "TRXabc123def456ghi789jkl",
    "status": "PENDING_REVIEW",
    "createdAt": "2026-03-06T11:00:00.000Z"
  }
}

curl -X DELETE https://api.zyndpay.io/v1/withdrawals/WD_ID \
  -H "X-Api-Key: YOUR_API_KEY"

curl -X POST https://api.zyndpay.io/v1/bulk-payments \
  -H "X-Api-Key: zyp_live_sk_..." \
  -H "Content-Type: application/json" \
  -d '{ "label": "Vendor payouts April 2026" }'

curl -X POST https://api.zyndpay.io/v1/bulk-payments/batch_abc/items \
  -H "X-Api-Key: zyp_live_sk_..." \
  -H "Content-Type: application/json" \
  -d '{
    "items": [
      { "walletAddress": "TXyz1...", "amount": "100.00", "recipientName": "Vendor A", "reference": "inv_001" },
      { "walletAddress": "TXyz2...", "amount": "250.00", "recipientName": "Vendor B", "reference": "inv_002" }
    ]
  }'

curl -X POST https://api.zyndpay.io/v1/bulk-payments/batch_abc/validate \
  -H "X-Api-Key: zyp_live_sk_..."

curl -X POST https://api.zyndpay.io/v1/bulk-payments/batch_abc/execute \
  -H "X-Api-Key: zyp_live_sk_..."

// Full bulk payment workflow
const batch = await zyndpay.bulkPayments.create({ label: 'Vendor payouts April 2026' });

await zyndpay.bulkPayments.addItems(batch.id, {
  items: [
    { walletAddress: 'TXyz1...', amount: '100.00', recipientName: 'Vendor A', reference: 'inv_001' },
    { walletAddress: 'TXyz2...', amount: '250.00', recipientName: 'Vendor B', reference: 'inv_002' },
  ],
});

const validation = await zyndpay.bulkPayments.validate(batch.id);
console.log(`Total fee: ${validation.totalFee} USDT`);

await zyndpay.bulkPayments.execute(batch.id);

// Poll for completion
const status = await zyndpay.bulkPayments.get(batch.id);
console.log(status.status); // PROCESSING | COMPLETED | PARTIALLY_COMPLETED

# Create batch
batch = client.bulk_payments.create(label="April payouts")

# Add recipients
client.bulk_payments.add_items(batch["id"], [
    {"walletAddress": "TRON_ADDRESS_1", "amount": "50.00", "recipientName": "Vendor A"},
    {"walletAddress": "TRON_ADDRESS_2", "amount": "75.00", "recipientName": "Vendor B"},
])

# Validate then execute
client.bulk_payments.validate(batch["id"])
client.bulk_payments.execute(batch["id"])

// Create batch
$batch = $client->bulkPayments->create(['label' => 'April payouts']);

// Add recipients
$client->bulkPayments->addItems($batch['id'], [
    ['walletAddress' => 'TRON_ADDRESS_1', 'amount' => '50.00', 'recipientName' => 'Vendor A'],
    ['walletAddress' => 'TRON_ADDRESS_2', 'amount' => '75.00', 'recipientName' => 'Vendor B'],
]);

// Validate and execute
$client->bulkPayments->validate($batch['id']);
$client->bulkPayments->execute($batch['id']);

curl https://api.zyndpay.io/v1/bulk-payments/batch_abc \
  -H "X-Api-Key: zyp_live_sk_..."

curl https://api.zyndpay.io/v1/merchants/wallets \
  -H "X-Api-Key: YOUR_API_KEY"

const wallets = await zyndpay.wallets.list();
// Always identify a wallet by the (currency, rail) pair — XOF is split per rail.
const usdtWallet = wallets.find(w => w.currency === 'USDT_TRC20' && w.rail === 'TRC20');
const xofMomoWallet = wallets.find(w => w.currency === 'XOF' && w.rail === 'MOMO');
const xofCardWallet = wallets.find(w => w.currency === 'XOF' && w.rail === 'CARD');
console.log(usdtWallet.id, usdtWallet.balance);
console.log(xofMomoWallet.balance, xofCardWallet.balance);

wallets = client.wallets.list()
for w in wallets:
    print(f"{w['currency']} ({w['rail']}): {w['balance']}")

$wallets = $client->wallets->list();
foreach ($wallets as $wallet) {
    echo $wallet['currency'] . ': ' . $wallet['balance'] . "\n";
}

curl -X POST https://api.zyndpay.io/v1/wallets/whitelist \
  -H "Authorization: Bearer zyp_live_sk_..." \
  -H "Content-Type: application/json" \
  -d '{
    "currency": "USDT_TRC20",
    "chain": "TRON",
    "address": "TRX_ADDRESS_HERE",
    "label": "My payout wallet",
    "usageContexts": ["WITHDRAWAL", "PAYOUT"]
  }'

const entry = await zyndpay.whitelist.add({
  currency: 'USDT_TRC20',
  chain: 'TRON',
  address: 'TRX_ADDRESS_HERE',
  label: 'My payout wallet',
  usageContexts: ['WITHDRAWAL', 'PAYOUT'], // optional, defaults to ['WITHDRAWAL']
});
// entry.availableAt — earliest time this address can receive a withdrawal
console.log('Available for withdrawal at:', entry.availableAt);

curl -X POST https://api.zyndpay.io/v1/wallets/whitelist/bulk \
  -H "Authorization: Bearer zyp_live_sk_..." \
  -H "Content-Type: application/json" \
  -d '{
    "addresses": [
      { "address": "TRX_ADDRESS_1", "label": "Customer wallet A" },
      { "address": "TRX_ADDRESS_2", "label": "Customer wallet B" }
    ],
    "usageContexts": ["WITHDRAWAL", "PAYOUT"]
  }'

// Add up to 500 addresses per call
const result = await zyndpay.whitelist.bulkAdd({
  addresses: [
    { address: 'TRX_ADDRESS_1', label: 'Customer wallet A' },
    { address: 'TRX_ADDRESS_2', label: 'Customer wallet B' },
  ],
  usageContexts: ['WITHDRAWAL', 'PAYOUT'], // applied to every address in the batch
});
console.log(`Added: ${result.added.length}`);
console.log(`Already existed: ${result.alreadyExists.length}`);
console.log(`Invalid: ${result.invalid.length}`);
// Each added entry includes availableAt (24h from now)

curl -X PATCH https://api.zyndpay.io/v1/wallets/whitelist/ENTRY_ID/contexts \
  -H "Authorization: Bearer zyp_live_sk_..." \
  -H "Content-Type: application/json" \
  -d '{
    "usageContexts": ["WITHDRAWAL", "PAYOUT"]
  }'

curl https://api.zyndpay.io/v1/wallets/whitelist \
  -H "Authorization: Bearer zyp_live_sk_..."

curl -X POST https://api.zyndpay.io/v1/merchants/fiat-destinations \
  -H "X-Api-Key: zyp_live_sk_..." \
  -H "Content-Type: application/json" \
  -d '{
    "kind": "MOMO",
    "label": "Orange Money BF",
    "momoOperator": "ORANGE_BF",
    "momoPhone": "+22670123456",
    "isPrimary": true
  }'

// Register a mobile money destination
const dest = await zyndpay.fiatDestinations.create({
  kind: 'MOMO',
  label: 'Orange Money BF',
  momoOperator: 'ORANGE_BF',
  momoPhone: '+22670123456',
  isPrimary: true,
});
// Note: 24-hour cooldown before first use (BCEAO compliance)

curl "https://api.zyndpay.io/v1/conversions/wallet/preview?fromCurrency=XOF&toCurrency=USDT&amount=50000" \
  -H "X-Api-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json"

curl https://api.zyndpay.io/v1/conversions \
  -H "X-Api-Key: YOUR_API_KEY"

// Convert XOF earnings (MOMO rail) to USDT
const wallets = await zyndpay.wallets.list();
const xof = wallets.find(w => w.currency === 'XOF' && w.rail === 'MOMO')!;
const usdt = wallets.find(w => w.currency === 'USDT_TRC20' && w.rail === 'TRC20')!;

const conversion = await zyndpay.conversions.convertBetweenWallets({
  fromWalletId: xof.id,
  toWalletId: usdt.id,
  fromAmount: '50000',
});
console.log(`Converted: ${conversion.fromAmount} ${conversion.fromCurrency}`);
console.log(`Received: ${conversion.toAmountNet} ${conversion.toCurrency}`);

from zyndpay import ZyndPay

client = ZyndPay(api_key="YOUR_API_KEY")

wallets = client.wallets.list()
usdt_wallet = next(w for w in wallets if w["currency"] == "USDT_TRC20")
xof_wallet = next(w for w in wallets if w["currency"] == "XOF")

conversion = client.conversions.convert_between_wallets(
    from_wallet_id=usdt_wallet["id"],
    to_wallet_id=xof_wallet["id"],
    from_amount="100.00",
)
print(conversion["id"], conversion["status"])

curl https://api.zyndpay.io/v1/transactions/TX_ID \
  -H "X-Api-Key: YOUR_API_KEY"

curl "https://api.zyndpay.io/v1/transactions?limit=20&type=PAYIN" \
  -H "X-Api-Key: YOUR_API_KEY"

const txs = await zyndpay.transactions.list({
  type: 'PAYIN',
  status: 'CONFIRMED',
  from: '2026-01-01',
  to: '2026-04-30',
});
console.log(`${txs.total} transactions found`);

txns = client.transactions.list(limit=20, type="PAYIN")
for t in txns["items"]:
    print(t["id"], t["type"], t["status"], t["amountRequested"])

$result = $client->transactions->list([
    'limit' => 20,
    'type' => 'PAYIN',
]);

foreach ($result['items'] as $tx) {
    echo $tx['id'] . ' ' . $tx['status'] . "\n";
}

curl "https://api.zyndpay.io/v1/transactions/export?from=2026-01-01&to=2026-12-31" \
  -H "X-Api-Key: YOUR_API_KEY" -o transactions.csv

// Download CSV export
const csv = await zyndpay.transactions.export({
  from: '2026-01-01',
  to: '2026-04-30',
});
// csv is a string — write to file or send to browser

// Download PDF report
const pdf = await zyndpay.transactions.exportPdf();

{
  "event": "payin.confirmed",
  "data": {
    "transactionId": "cma1xyz8f0001yx5k9abc1234",
    "status": "CONFIRMED",
    "currency": "XOF",
    "chain": "TRON",
    "externalRef": "order_123",
    "amount": "9300.00",
    "amountRequested": "9300.00",
    "txHash": "abc123def456...",
    "confirmedAt": "2026-03-06T11:01:02.000Z",
    "pricingCurrency": "USDT_TRC20",
    "pricingAmount": "15.00",
    "fxRate": "620.00000000"
  },
  "createdAt": "2026-03-06T11:01:03.000Z"
}

const crypto = require('crypto');

app.post('/webhook', express.raw({ type: 'application/json' }), (req, res) => {
  const sig = req.headers['zyndpay-signature'];
  const [tPart, v1Part] = sig.split(',');
  const timestamp = tPart.split('=')[1];
  const received  = v1Part.split('=')[1];

  // Reject events older than 5 minutes
  const age = Math.abs(Date.now() / 1000 - parseInt(timestamp) / 1000);
  if (age > 300) return res.status(400).send('Webhook too old');

  const expected = crypto
    .createHmac('sha256', process.env.WEBHOOK_SECRET)
    .update(`${timestamp}.${req.body}`)
    .digest('hex');

  // Use timing-safe comparison to prevent timing attacks
  if (!crypto.timingSafeEqual(Buffer.from(expected), Buffer.from(received))) {
    return res.status(400).send('Invalid signature');
  }

  const event = JSON.parse(req.body);
  // Handle event...
  res.json({ received: true });
});

const endpoint = await zyndpay.webhooks.createEndpoint({
  url: 'https://example.com/webhooks/zyndpay',
  events: ['payin.confirmed', 'payout.failed', 'withdrawal.confirmed'],
});
// Store endpoint.secret (whs_* prefix) — shown only once!
process.env.ZYNDPAY_WEBHOOK_SECRET = endpoint.secret;

{
  "event": "payin.confirmed",
  "data": {
    "transactionId": "cma1xyz8f0001yx5k9abc1234",
    "status": "CONFIRMED",
    "currency": "XOF",
    "chain": "TRON",
    "externalRef": "order_123",
    "amount": "9300.00",
    "amountRequested": "9300.00",
    "txHash": "abc123def456...",
    "confirmedAt": "2026-03-06T11:01:02.000Z",
    "pricingCurrency": "USDT_TRC20",
    "pricingAmount": "15.00",
    "fxRate": "620.00000000"
  },
  "createdAt": "2026-03-06T11:01:03.000Z"
}

{
  "event": "payout.confirmed",
  "data": {
    "transactionId": "tx_sample_payout123",
    "status": "CONFIRMED",
    "currency": "USDT_TRC20",
    "chain": "TRON",
    "amount": "50.00",
    "fee": "1.50",
    "destinationAddress": "TXyz1234567890AbCdEfGhIjKlMnOpQrSt",
    "txHash": "0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890",
    "externalRef": "vendor_invoice_456",
    "confirmedAt": "2026-01-15T12:01:00.000Z"
  },
  "createdAt": "2026-01-15T12:01:05.000Z"
}

{
  "event": "withdrawal.confirmed",
  "data": {
    "transactionId": "wdr_sample_abc123",
    "status": "CONFIRMED",
    "currency": "USDT_TRC20",
    "chain": "TRON",
    "amount": "500.00",
    "fee": "5.00",
    "netAmount": "495.00",
    "toAddress": "TXyz1234567890AbCdEfGhIjKlMnOpQrSt",
    "txHash": "0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890",
    "confirmedAt": "2026-01-15T12:01:00.000Z"
  },
  "createdAt": "2026-01-15T12:01:05.000Z"
}

curl -X POST https://api.zyndpay.io/v1/webhooks/test \
  -H "X-Api-Key: zyp_live_sk_..." \
  -H "Content-Type: application/json" \
  -d '{
    "endpointId": "your-endpoint-id",
    "eventType": "payin.confirmed"
  }'

{
  "success": true,
  "data": {
    "message": "Test event sent",
    "deliveryId": "9270e4aa-8391-4e3f-a70b-23c431714b84"
  }
}

npm install @zyndpay/sdk

const { ZyndPay } = require('@zyndpay/sdk');

const client = new ZyndPay({
  apiKey: 'zyp_live_sk_...',
  webhookSecret: process.env.ZYNDPAY_WEBHOOK_SECRET,
});

// Create a payment
const payment = await client.payins.create({
  amount: '100.00',
  externalRef: 'order_123',
});
console.log(payment.address);

// Verify a webhook (uses raw body, not parsed JSON)
const event = client.webhooks.verify(
  rawBody,
  req.headers['zyndpay-signature']
);

import { ZyndPay } from '@zyndpay/sdk';
import express from 'express';

// 1. Initialize the SDK
const client = new ZyndPay({
  apiKey: process.env.ZYNDPAY_API_KEY,       // zyp_live_sk_...
  webhookSecret: process.env.WEBHOOK_SECRET,
});

// 2. Create a pay-in (generates a TRON deposit address for your customer)
const payment = await client.payins.create({
  amount: '100.00',
  externalRef: 'order_123',
  expiresInSeconds: 3600,
  successUrl: 'https://yoursite.com/payment/success',
});
// Send payment.paymentUrl or payment.address to your customer
console.log('Deposit address:', payment.address);
console.log('Payment page:', payment.paymentUrl);

// 3. Handle webhook events
const app = express();
app.post('/webhook', express.raw({ type: 'application/json' }), (req, res) => {
  // Always verify using the raw body — never parsed JSON
  const event = client.webhooks.verify(
    req.body,
    req.headers['zyndpay-signature'] as string,
  );

  switch (event.event) {
    case 'payin.confirmed':
      console.log(`Payment confirmed: ${event.data.amount} USDT — ${event.data.externalRef}`);
      // Fulfill the order, unlock access, send receipt, etc.
      break;
    case 'payin.expired':
      console.log(`Payment expired: ${event.data.externalRef}`);
      break;
  }
  res.json({ received: true });
});

// 4. Check payment status anytime
const status = await client.payins.get(payment.transactionId);
console.log('Status:', status.status); // AWAITING_PAYMENT → CONFIRMING → CONFIRMED

// Convert XOF earnings (MOMO rail) to USDT
const wallets = await zyndpay.wallets.list();
const xof = wallets.find(w => w.currency === 'XOF' && w.rail === 'MOMO')!;
const usdt = wallets.find(w => w.currency === 'USDT_TRC20' && w.rail === 'TRC20')!;

const conversion = await zyndpay.conversions.convertBetweenWallets({
  fromWalletId: xof.id,
  toWalletId: usdt.id,
  fromAmount: '50000',
});
console.log(`Converted: ${conversion.fromAmount} ${conversion.fromCurrency}`);
console.log(`Received: ${conversion.toAmountNet} ${conversion.toCurrency}`);

// Register a mobile money destination
const dest = await zyndpay.fiatDestinations.create({
  kind: 'MOMO',
  label: 'Orange Money BF',
  momoOperator: 'ORANGE_BF',
  momoPhone: '+22670123456',
  isPrimary: true,
});
// Note: 24-hour cooldown before first use (BCEAO compliance)

const wallets = await zyndpay.wallets.list();
// Always identify a wallet by the (currency, rail) pair — XOF is split per rail.
const usdtWallet = wallets.find(w => w.currency === 'USDT_TRC20' && w.rail === 'TRC20');
const xofMomoWallet = wallets.find(w => w.currency === 'XOF' && w.rail === 'MOMO');
const xofCardWallet = wallets.find(w => w.currency === 'XOF' && w.rail === 'CARD');
console.log(usdtWallet.id, usdtWallet.balance);
console.log(xofMomoWallet.balance, xofCardWallet.balance);

// Download CSV export
const csv = await zyndpay.transactions.export({
  from: '2026-01-01',
  to: '2026-04-30',
});
// csv is a string — write to file or send to browser

// Download PDF report
const pdf = await zyndpay.transactions.exportPdf();

const balances = await zyndpay.balances.getAll();
// { USDT_TRC20: '245.50', XOF: '150000', USD: '0' }

const estimate = await zyndpay.payouts.estimate({
  amount: '100.00',
  currency: 'USDT_TRC20',
  chain: 'TRON',
  destinationAddress: 'TXyz1234567890abcdef1234567890abcde',
});
console.log(`Fee: ${estimate.fee} USDT`);
console.log(`Total deducted: ${estimate.totalDebited} USDT`);
console.log(`Sufficient balance: ${estimate.sufficient}`);

pip install zyndpay

from zyndpay import ZyndPay

client = ZyndPay(
    api_key="zyp_live_sk_...",
    webhook_secret=os.environ.get("ZYNDPAY_WEBHOOK_SECRET"),
)

payment = client.payins.create(
    amount="100.00",
    external_ref="order_123"
)
print(payment["address"])

import os
from zyndpay import ZyndPay
from flask import Flask, request, jsonify

# 1. Initialize the SDK
client = ZyndPay(
    api_key=os.environ["ZYNDPAY_API_KEY"],        # zyp_live_sk_...
    webhook_secret=os.environ["WEBHOOK_SECRET"],
)

# 2. Create a pay-in (generates a TRON deposit address for your customer)
payment = client.payins.create(
    amount="100.00",
    external_ref="order_123",
    expires_in_seconds=3600,
    success_url="https://yoursite.com/payment/success",
)
# Send payment["paymentUrl"] or payment["address"] to your customer
print("Deposit address:", payment["address"])
print("Payment page:", payment["paymentUrl"])

# 3. Handle webhook events
app = Flask(__name__)

@app.post("/webhook")
def handle_webhook():
    # Always verify using the raw body — never parsed JSON
    event = client.webhooks.verify(
        request.get_data(),
        request.headers.get("Zyndpay-Signature"),
    )

    if event["event"] == "payin.confirmed":
        data = event["data"]
        print(f"Payment confirmed: {data['amount']} USDT — {data['externalRef']}")
        # Fulfill the order, unlock access, send receipt, etc.
    elif event["event"] == "payin.expired":
        print("Payment expired:", event["data"]["externalRef"])

    return jsonify(received=True)

# 4. Check payment status anytime
status = client.payins.get(payment["transactionId"])
print("Status:", status["status"])  # AWAITING_PAYMENT → CONFIRMING → CONFIRMED

estimate = zyndpay.payouts.estimate(
    amount='100.00',
    destination_address='TXyz1234567890abcdef1234567890abcde',
)
print(f"Fee: {estimate['fee']} USDT")
print(f"Total deducted: {estimate['totalDebited']} USDT")
print(f"Sufficient: {estimate['sufficient']}")

composer require zyndpay/zyndpay-php

<?php
require_once 'vendor/autoload.php';

$client = new ZyndPay\ZyndPay('zyp_live_sk_...', [
    'webhook_secret' => getenv('ZYNDPAY_WEBHOOK_SECRET'),
]);

// Create a payment
$payment = $client->payins->create([
    'amount' => '100.00',
    'externalRef' => 'order_123',
]);
echo $payment['address'];

// Verify a webhook
$event = $client->webhooks->verify(
    $rawBody,
    $_SERVER['HTTP_ZYNDPAY_SIGNATURE']
);

<?php
require_once 'vendor/autoload.php';

// 1. Initialize the SDK
$client = new ZyndPay\ZyndPay(
    getenv('ZYNDPAY_API_KEY'),   // zyp_live_sk_...
    ['webhook_secret' => getenv('WEBHOOK_SECRET')]
);

// 2. Create a pay-in (generates a TRON deposit address for your customer)
$payment = $client->payins->create([
    'amount' => '100.00',
    'externalRef' => 'order_123',
    'expiresInSeconds' => 3600,
    'successUrl' => 'https://yoursite.com/payment/success',
]);
// Send $payment['paymentUrl'] or $payment['address'] to your customer
echo "Deposit address: " . $payment['address'] . "\n";
echo "Payment page: " . $payment['paymentUrl'] . "\n";

// 3. Handle webhook events (in your webhook endpoint file)
$rawBody   = file_get_contents('php://input');
$sigHeader = $_SERVER['HTTP_ZYNDPAY_SIGNATURE'];
$event     = $client->webhooks->verify($rawBody, $sigHeader);

switch ($event['event']) {
    case 'payin.confirmed':
        $data = $event['data'];
        echo "Payment confirmed: {$data['amount']} USDT — {$data['externalRef']}\n";
        // Fulfill the order, unlock access, send receipt, etc.
        break;
    case 'payin.expired':
        echo "Payment expired: " . $event['data']['externalRef'] . "\n";
        break;
}
http_response_code(200);
echo json_encode(['received' => true]);

// 4. Check payment status anytime
$status = $client->payins->get($payment['transactionId']);
echo "Status: " . $status['status'] . "\n"; // AWAITING_PAYMENT → CONFIRMING → CONFIRMED

$estimate = $zyndpay->payouts->estimate([
    'amount' => '100.00',
    'destinationAddress' => 'TXyz1234567890abcdef1234567890abcde',
]);
echo "Fee: "   . $estimate['fee']          . " USDT\n";
echo "Total: " . $estimate['totalDebited'] . " USDT\n";

# Using the sandbox API key (zyp_test_sk_...)
curl -X POST "https://api.zyndpay.io/v1/payments?sandbox=true" \
  -H "X-Api-Key: zyp_test_sk_..." \
  -H "Content-Type: application/json" \
  -d '{
    "amount": "100",
    "externalRef": "test_order_001"
  }'

import { ZyndPay } from '@zyndpay/sdk';

const zyndpay = new ZyndPay({ apiKey: 'zyp_test_sk_...' });

// 1. Create a sandbox payin
const payin = await zyndpay.payins.create({
  amount: '100',
  sandbox: true,
  externalRef: 'test_order_001',
});

// 2. Instantly simulate confirmation (fires the payin.confirmed webhook)
//    simulate() returns an ack { message, transactionId }, not the payin —
//    fetch the post-confirmation state with get().
await zyndpay.payins.simulate(payin.transactionId);

// 3. Read the final status
const tx = await zyndpay.payins.get(payin.transactionId);
console.log('Final status:', tx.status); // "CONFIRMED"

# Reset all sandbox transactions (useful for clean test runs)
curl -X POST https://api.zyndpay.io/v1/sandbox/reset \
  -H "X-Api-Key: zyp_test_sk_..."

curl -X POST \
  https://api.zyndpay.io/v1/sandbox/payments/{id}/simulate \
  -H "X-Api-Key: zyp_test_sk_..."

{
  "success": true,
  "data": {
    "message": "Payin simulation triggered",
    "transactionId": "f4b2cb0f-08ce-4408-88d4-0a678ca0aae2"
  }
}

{
  "success": false,
  "error": {
    "code": "AMOUNT_TOO_LOW",
    "message": "Minimum payin amount is 1 USDT"
  },
  "statusCode": 400
}