Your App  ──(API Key)──►  DGateway  ──(Platform Credentials)──►  Iotec / Stripe / ...

1. DGateway validates your API key
2. Routes to the provider you specify (defaults to Iotec if omitted)
3. Processes the payment using platform credentials
4. Returns a unified response with a reference ID

# .env.local

# DGateway API
DGATEWAY_API_URL='https://dgatewayapi.desispay.com'
DGATEWAY_API_KEY='dgw_live_your_api_key_here'

// lib/dgateway.ts — server-side only

const API_URL = process.env.DGATEWAY_API_URL || "https://dgatewayapi.desispay.com";
const API_KEY = process.env.DGATEWAY_API_KEY || "";

interface CollectParams {
  amount: number;
  currency: string;
  phone_number: string;
  provider?: string;       // "iotec" | "stripe" | "relworx" — defaults to "iotec"
  description?: string;
  metadata?: Record<string, unknown>;
}

export async function collectPayment(params: CollectParams) {
  const res = await fetch(`${API_URL}/v1/payments/collect`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "X-Api-Key": API_KEY,
    },
    body: JSON.stringify(params),
  });
  return res.json();
}

export async function verifyTransaction(reference: string) {
  const res = await fetch(`${API_URL}/v1/webhooks/verify`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "X-Api-Key": API_KEY,
    },
    body: JSON.stringify({ reference }),
  });
  return res.json();
}

// app/api/checkout/route.ts
import { NextRequest, NextResponse } from "next/server";
import { collectPayment } from "@/lib/dgateway";

export async function POST(request: NextRequest) {
  const body = await request.json();
  const { amount, currency, phone_number, provider, description } = body;

  if (!amount || !currency) {
    return NextResponse.json(
      { error: { code: "VALIDATION_ERROR", message: "amount and currency are required" } },
      { status: 400 }
    );
  }

  const result = await collectPayment({
    amount,
    currency,
    phone_number: phone_number || "0000000000",
    provider,
    description,
  });

  if (result.error) {
    return NextResponse.json(result, { status: 400 });
  }

  return NextResponse.json(result);
}

// Standard response for all providers
{
  "data": {
    "reference": "txn_abc123def456",
    "provider": "iotec",
    "status": "pending",
    "amount": 37500,
    "currency": "UGX"
  }
}

// Stripe additionally returns:
{
  "data": {
    "reference": "txn_abc123def456",
    "provider": "stripe",
    "status": "pending",
    "client_secret": "pi_xxx_secret_yyy",
    "stripe_publishable_key": "pk_live_..."
  }
}

// app/api/checkout/status/route.ts
import { NextRequest, NextResponse } from "next/server";
import { verifyTransaction } from "@/lib/dgateway";

export async function POST(request: NextRequest) {
  const { reference } = await request.json();

  if (!reference) {
    return NextResponse.json(
      { error: { code: "VALIDATION_ERROR", message: "reference is required" } },
      { status: 400 }
    );
  }

  const result = await verifyTransaction(reference);
  return NextResponse.json(result);
}

type PaymentMethod = "iotec" | "stripe" | null;
type PaymentStatus =
  | "idle"           // Selecting method / entering info
  | "creating"       // API call in progress
  | "awaiting_card"  // Stripe Elements mounted, waiting for card entry
  | "processing"     // Payment submitted, polling for result
  | "completed"      // Payment succeeded
  | "failed";        // Payment failed

const createIotecPayment = async (phoneNumber: string) => {
  setStatus("creating");

  const res = await fetch("/api/checkout", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      amount: 37500,          // Amount in UGX
      currency: "UGX",
      phone_number: phoneNumber,  // e.g. "256771234567"
      provider: "iotec",
      description: "Order #1234",
    }),
  });

  const data = await res.json();

  if (data.error) {
    setError(data.error.message);
    setStatus("idle");
    return;
  }

  setReference(data.data.reference);
  setStatus("processing");
  pollStatus(data.data.reference);
};

<input
  type="tel"
  placeholder="e.g. 256771234567"
  value={phone}
  onChange={(e) => setPhone(e.target.value)}
/>
<p className="text-xs text-gray-500">
  Enter with country code (e.g. 256 for Uganda)
</p>

// Install Stripe packages first:
// pnpm add @stripe/react-stripe-js @stripe/stripe-js

import { loadStripe } from "@stripe/stripe-js";
import { Elements, PaymentElement, useStripe, useElements } from "@stripe/react-stripe-js";

const createStripePayment = async () => {
  setStatus("creating");

  const res = await fetch("/api/checkout", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      amount: 10.00,
      currency: "USD",
      provider: "stripe",
      description: "Order #1234",
    }),
  });

  const data = await res.json();
  const { client_secret, stripe_publishable_key, reference } = data.data;

  setReference(reference);
  setClientSecret(client_secret);
  setStripePromise(loadStripe(stripe_publishable_key));
  setStatus("awaiting_card");
};

{status === "awaiting_card" && clientSecret && stripePromise && (
  <Elements
    stripe={stripePromise}
    options={{
      clientSecret,
      appearance: { theme: "night", variables: { colorPrimary: "#6c5ce7" } },
    }}
  >
    <StripeCardForm
      onSuccess={() => { setStatus("processing"); pollStatus(reference); }}
      onError={(msg) => setError(msg)}
    />
  </Elements>
)}

function StripeCardForm({ onSuccess, onError }) {
  const stripe = useStripe();
  const elements = useElements();

  const handleSubmit = async (e) => {
    e.preventDefault();
    const { error, paymentIntent } = await stripe.confirmPayment({
      elements,
      redirect: "if_required",
    });
    if (error) { onError(error.message); return; }
    if (paymentIntent?.status === "succeeded") onSuccess();
  };

  return (
    <form onSubmit={handleSubmit}>
      <PaymentElement />
      <button type="submit">Pay Now</button>
    </form>
  );
}

const pollStatus = useCallback((ref: string) => {
  let attempts = 0;
  const maxAttempts = 60; // 60 × 5s = 5 minutes

  const poll = async () => {
    if (attempts >= maxAttempts) {
      setError("Payment verification timed out.");
      setStatus("failed");
      return;
    }
    attempts++;

    try {
      const res = await fetch("/api/checkout/status", {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({ reference: ref }),
      });
      const data = await res.json();

      if (data.data?.status === "completed") {
        setStatus("completed");
        return;
      }
      if (data.data?.status === "failed") {
        setError("Payment failed. Please try again.");
        setStatus("failed");
        return;
      }
    } catch {
      // Network error — keep polling
    }

    setTimeout(poll, 5000);
  };

  setTimeout(poll, 3000); // First poll after 3s
}, []);

// Success
if (status === "completed") return (
  <div className="text-center">
    <CheckCircle className="text-green-500 mx-auto" />
    <h1>Payment Successful!</h1>
    <p>Reference: {reference}</p>
  </div>
);

// Failed
if (status === "failed") return (
  <div className="text-center">
    <XCircle className="text-red-500 mx-auto" />
    <p>{error}</p>
    <button onClick={() => { setStatus("idle"); setMethod(null); }}>
      Try Again
    </button>
  </div>
);

// Processing (waiting for Iotec confirmation or Stripe verification)
if (status === "processing") return (
  <div className="text-center">
    <Loader2 className="animate-spin mx-auto" />
    <p>
      {method === "iotec"
        ? "Check your phone and confirm the payment prompt."
        : "Verifying your payment..."}
    </p>
  </div>
);

const USD_TO_UGX = 3750; // Demo rate — use a real API in production

const totalUSD = 10.00;
const totalUGX = Math.round(totalUSD * USD_TO_UGX); // 37,500 UGX

// Send the correct amount per provider
body: JSON.stringify({
  amount: provider === "iotec" ? totalUGX : totalUSD,
  currency: provider === "iotec" ? "UGX" : "USD",
  provider,
})

{
  "error": {
    "code": "PROVIDER_ERROR",
    "message": "The Payer field is required"
  }
}

// Always wrap API calls in try/catch
try {
  const res = await fetch("/api/checkout", { ... });
  const data = await res.json();

  if (data.error) {
    setError(data.error.message || "Payment failed");
    setStatus("idle");
    return;
  }
} catch {
  setError("Network error. Please try again.");
  setStatus("idle");
}

// GET /v1/payments/transactions/:ref
{
  "data": {
    "reference": "txn_abc123",
    "status": "failed",
    "failure_reason": "The Payer account has insufficient funds",
    "amount": 5000,
    "currency": "UGX",
    "provider_slug": "iotec"
  }
}

// GET /api/provider-health (no auth required)
{
  "data": [
    {
      "provider_slug": "iotec",
      "vendor": "mtn",
      "currency": "UGX",
      "is_healthy": true,
      "last_check_at": "2026-03-25T06:00:00Z",
      "last_error": ""
    },
    {
      "provider_slug": "iotec",
      "vendor": "airtel",
      "currency": "UGX",
      "is_healthy": false,
      "last_error": "Service temporarily unavailable",
      "failing_since": "2026-03-24T16:21:00Z"
    }
  ]
}

{
  "error": {
    "code": "PROVIDER_LINE_DOWN",
    "message": "iotec AIRTEL line is currently experiencing service issues..."
  }
}

1. Your server sends POST /v1/withdrawals with amount, method & destination (provider defaults to "iotec")
2. DGateway immediately disburses funds to the destination via the specified provider
3. If disbursement succeeds → status is "completed"
4. If disbursement fails → status is "failed" with a note explaining the reason

// lib/dgateway.ts — add to your existing server-side client

interface WithdrawalParams {
  amount: number;
  currency: string;
  provider?: string;            // "iotec" or "relworx" — defaults to "iotec"
  method: "mobile_money" | "bank_transfer";
  destination: string;          // Phone number or bank account
  destination_name?: string;    // Recipient name
  bank_name?: string;           // Required for bank_transfer
  note?: string;                // Optional note
}

export async function requestWithdrawal(params: WithdrawalParams) {
  const res = await fetch(`${API_URL}/v1/withdrawals`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "X-Api-Key": API_KEY,
    },
    body: JSON.stringify(params),
  });
  return res.json();
}

// app/api/withdraw/route.ts
import { NextRequest, NextResponse } from "next/server";
import { requestWithdrawal } from "@/lib/dgateway";

export async function POST(request: NextRequest) {
  const body = await request.json();
  const { amount, currency, provider, method, destination, destination_name, bank_name, note } = body;

  if (!amount || !currency || !method || !destination) {
    return NextResponse.json(
      { error: { code: "VALIDATION_ERROR", message: "amount, currency, method and destination are required" } },
      { status: 400 }
    );
  }

  const result = await requestWithdrawal({
    amount,
    currency,
    provider,       // optional — defaults to "iotec" on the server
    method,
    destination,
    destination_name,
    bank_name,
    note,
  });

  if (result.error) {
    return NextResponse.json(result, { status: 400 });
  }

  return NextResponse.json(result);
}

// POST /v1/withdrawals
{
  "amount": 500000,
  "currency": "UGX",
  "provider": "iotec",
  "method": "mobile_money",
  "destination": "256771234567",
  "destination_name": "John Doe",
  "note": "Monthly payout"
}

// Response (201 Created)
{
  "data": {
    "id": 12,
    "app_id": 1,
    "amount": 500000,
    "currency": "UGX",
    "provider_slug": "iotec",
    "method": "mobile_money",
    "destination": "256771234567",
    "destination_name": "John Doe",
    "status": "completed",
    "note": "Monthly payout",
    "created_at": "2025-06-15T10:30:00Z"
  },
  "message": "Withdrawal disbursed successfully"
}

{
  "amount": 2000000,
  "currency": "UGX",
  "provider": "relworx",
  "method": "bank_transfer",
  "destination": "0012345678901",
  "destination_name": "Acme Ltd",
  "bank_name": "Stanbic Bank Uganda",
  "note": "Q2 revenue withdrawal"
}

// lib/dgateway.ts — add to your existing client

export async function listWithdrawals(params?: {
  page?: number;
  per_page?: number;
  status?: string;
}) {
  const query = new URLSearchParams();
  if (params?.page) query.set("page", String(params.page));
  if (params?.per_page) query.set("per_page", String(params.per_page));
  if (params?.status) query.set("status", params.status);

  const res = await fetch(`${API_URL}/v1/withdrawals?${query.toString()}`, {
    headers: { "X-Api-Key": API_KEY },
  });
  return res.json();
}

// GET /v1/withdrawals?page=1&per_page=10&status=pending
{
  "data": [
    {
      "id": 12,
      "app_id": 1,
      "amount": 500000,
      "currency": "UGX",
      "method": "mobile_money",
      "destination": "256771234567",
      "destination_name": "John Doe",
      "status": "pending",
      "note": "Monthly payout",
      "created_at": "2025-06-15T10:30:00Z"
    }
  ],
  "meta": {
    "page": 1,
    "per_page": 10,
    "total": 1,
    "total_pages": 1
  }
}

# .env.local
DGATEWAY_API_URL='https://dgatewayapi.desispay.com'
DGATEWAY_API_KEY='dgw_live_your_api_key_here'

// Server-side: lib/dgateway.ts
const API_URL = process.env.DGATEWAY_API_URL!;
const API_KEY = process.env.DGATEWAY_API_KEY!;

export async function collectKES(phone: string, amount: number, description?: string) {
  const res = await fetch(`${API_URL}/v1/payments/collect`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "X-Api-Key": API_KEY,
    },
    body: JSON.stringify({
      amount,                       // e.g. 1500 (KES)
      currency: "KES",
      phone_number: phone,          // e.g. "254712345678"
      provider: "relworx",          // required
      description,
    }),
  });
  return res.json();
}

// API route: app/api/checkout/route.ts
export async function POST(request: Request) {
  const { phone, amount, description } = await request.json();
  const result = await collectKES(phone, amount, description);
  return Response.json(result);
}

const handleMpesaPayment = async () => {
  setStatus("creating");

  const res = await fetch("/api/checkout", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      phone: "254712345678",    // Customer's Safaricom number
      amount: 1500,             // KES 1,500
      description: "Order #100",
    }),
  });

  const data = await res.json();
  if (data.error) { setError(data.error.message); return; }

  // Customer receives STK push on their phone
  setReference(data.data.reference);
  setStatus("processing");
  pollStatus(data.data.reference);  // Poll every 5s until completed/failed
};

// Send money to a Kenyan M-Pesa number
export async function disburseKES(phone: string, amount: number) {
  const res = await fetch(`${API_URL}/v1/payments/disburse`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "X-Api-Key": API_KEY,
    },
    body: JSON.stringify({
      amount,
      currency: "KES",
      phone_number: phone,         // e.g. "254712345678"
      provider: "relworx",         // required
      description: "Payout",
    }),
  });
  return res.json();
}

# .env.local
DGATEWAY_API_URL='https://dgatewayapi.desispay.com'
DGATEWAY_API_KEY='dgw_live_your_api_key_here'

// Server-side: lib/dgateway.ts
const API_URL = process.env.DGATEWAY_API_URL!;
const API_KEY = process.env.DGATEWAY_API_KEY!;

export async function collectRWF(phone: string, amount: number, description?: string) {
  const res = await fetch(`${API_URL}/v1/payments/collect`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "X-Api-Key": API_KEY,
    },
    body: JSON.stringify({
      amount,                       // e.g. 5000 (RWF)
      currency: "RWF",
      phone_number: phone,          // e.g. "250781234567"
      provider: "relworx",          // required
      description,
    }),
  });
  return res.json();
}

// API route: app/api/checkout/route.ts
export async function POST(request: Request) {
  const { phone, amount, description } = await request.json();
  const result = await collectRWF(phone, amount, description);
  return Response.json(result);
}

const handleMomoPayment = async () => {
  setStatus("creating");

  const res = await fetch("/api/checkout", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      phone: "250781234567",    // Customer's MTN MoMo number
      amount: 5000,             // RWF 5,000
      description: "Order #200",
    }),
  });

  const data = await res.json();
  if (data.error) { setError(data.error.message); return; }

  // Customer receives USSD prompt on their phone
  setReference(data.data.reference);
  setStatus("processing");
  pollStatus(data.data.reference);  // Poll every 5s until completed/failed
};

// Send money to a Rwandan mobile money number
export async function disburseRWF(phone: string, amount: number) {
  const res = await fetch(`${API_URL}/v1/payments/disburse`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "X-Api-Key": API_KEY,
    },
    body: JSON.stringify({
      amount,
      currency: "RWF",
      phone_number: phone,         // e.g. "250781234567"
      provider: "relworx",         // required
      description: "Payout",
    }),
  });
  return res.json();
}

# .env.local
DGATEWAY_API_URL='https://dgatewayapi.desispay.com'
DGATEWAY_API_KEY='dgw_live_your_api_key_here'

// Server-side: lib/dgateway.ts
const API_URL = process.env.DGATEWAY_API_URL!;
const API_KEY = process.env.DGATEWAY_API_KEY!;

export async function collectTZS(phone: string, amount: number, description?: string) {
  const res = await fetch(`${API_URL}/v1/payments/collect`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "X-Api-Key": API_KEY,
    },
    body: JSON.stringify({
      amount,                       // e.g. 10000 (TZS)
      currency: "TZS",
      phone_number: phone,          // e.g. "255712345678"
      provider: "relworx",          // required
      description,
    }),
  });
  return res.json();
}

// API route: app/api/checkout/route.ts
export async function POST(request: Request) {
  const { phone, amount, description } = await request.json();
  const result = await collectTZS(phone, amount, description);
  return Response.json(result);
}

const handleMobilePayment = async () => {
  setStatus("creating");

  const res = await fetch("/api/checkout", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      phone: "255712345678",    // Customer's Vodacom M-Pesa number
      amount: 10000,            // TZS 10,000
      description: "Order #300",
    }),
  });

  const data = await res.json();
  if (data.error) { setError(data.error.message); return; }

  // Customer receives USSD prompt on their phone
  setReference(data.data.reference);
  setStatus("processing");
  pollStatus(data.data.reference);  // Poll every 5s until completed/failed
};

// Send money to a Tanzanian mobile money number
export async function disburseTZS(phone: string, amount: number) {
  const res = await fetch(`${API_URL}/v1/payments/disburse`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "X-Api-Key": API_KEY,
    },
    body: JSON.stringify({
      amount,
      currency: "TZS",
      phone_number: phone,         // e.g. "255712345678"
      provider: "relworx",         // required
      description: "Payout",
    }),
  });
  return res.json();
}

# .env.local
DGATEWAY_API_URL='https://dgatewayapi.desispay.com'
DGATEWAY_API_KEY='dgw_live_your_api_key_here'

// Server-side: lib/dgateway.ts
const API_URL = process.env.DGATEWAY_API_URL!;
const API_KEY = process.env.DGATEWAY_API_KEY!;

export async function collectUGX(phone: string, amount: number, description?: string) {
  const res = await fetch(`${API_URL}/v1/payments/collect`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "X-Api-Key": API_KEY,
    },
    body: JSON.stringify({
      amount,                       // e.g. 50000 (UGX)
      currency: "UGX",
      phone_number: phone,          // e.g. "256771234567"
      provider: "iotec",            // required — "iotec" or "relworx"
      description,
    }),
  });
  return res.json();
}

// API route: app/api/checkout/route.ts
export async function POST(request: Request) {
  const { phone, amount, description } = await request.json();
  const result = await collectUGX(phone, amount, description);
  return Response.json(result);
}

const handleMomoPayment = async () => {
  setStatus("creating");

  const res = await fetch("/api/checkout", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      phone: "256771234567",    // Customer's MTN MoMo number
      amount: 50000,            // UGX 50,000
      description: "Order #400",
    }),
  });

  const data = await res.json();
  if (data.error) { setError(data.error.message); return; }

  // Customer receives USSD prompt on their phone
  setReference(data.data.reference);
  setStatus("processing");
  pollStatus(data.data.reference);  // Poll every 5s until completed/failed
};

// Send money to a Ugandan mobile money number
export async function disburseUGX(phone: string, amount: number) {
  const res = await fetch(`${API_URL}/v1/payments/disburse`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "X-Api-Key": API_KEY,
    },
    body: JSON.stringify({
      amount,
      currency: "UGX",
      phone_number: phone,         // e.g. "256771234567"
      provider: "iotec",           // required — "iotec" or "relworx"
      description: "Payout",
    }),
  });
  return res.json();
}

1. Create a Plan        →  Define amount, currency, interval (daily/weekly/monthly/yearly)
2. Subscribe a Customer  →  Attach a customer to a plan (email, name, phone)
3. Charge Each Cycle     →  POST to /charge to initiate a Mobile Money prompt
4. Manage Lifecycle      →  Pause, resume, or cancel subscriptions via API

POST /v1/subscriptions/plans
X-Api-Key: dgw_live_your_key_here

{
  "name": "Monthly Premium",
  "description": "Premium access billed monthly",
  "amount": 50000,
  "currency": "UGX",
  "interval": "monthly",        // "daily" | "weekly" | "monthly" | "yearly" | "custom"
  "interval_days": 0,           // only used when interval is "custom"
  "trial_days": 7,              // optional — free trial period
  "grace_days": 3,              // optional — days after due date before marking overdue
  "setup_fee": 10000,           // optional — one-time fee on first charge
  "max_cycles": 0,              // 0 = unlimited
  "metadata": {}                // optional
}

// Response (201)
{
  "data": {
    "id": 1,
    "name": "Monthly Premium",
    "amount": 50000,
    "currency": "UGX",
    "interval": "monthly",
    "is_active": true,
    "created_at": "2026-03-14T10:00:00Z"
  }
}

POST /v1/subscriptions
X-Api-Key: dgw_live_your_key_here

{
  "plan_id": 1,
  "customer_email": "jane@example.com",
  "customer_name": "Jane Doe",
  "customer_phone": "256771234567",
  "provider": "iotec",          // optional — defaults to "iotec"
  "start_now": true,            // true = first charge immediately
  "metadata": {}                // optional
}

// Response (201)
{
  "data": {
    "id": 5,
    "plan_id": 1,
    "customer_email": "jane@example.com",
    "customer_name": "Jane Doe",
    "status": "active",
    "current_cycle": 1,
    "next_due_date": "2026-04-14T10:00:00Z",
    "created_at": "2026-03-14T10:00:00Z"
  }
}

// Example: pause a subscription
POST /v1/subscriptions/5/pause
X-Api-Key: dgw_live_your_key_here

// Response
{ "message": "Subscription paused" }

// Example: cancel a subscription
POST /v1/subscriptions/5/cancel
X-Api-Key: dgw_live_your_key_here

// Response
{ "message": "Subscription cancelled" }

POST /v1/subscriptions/5/charge
X-Api-Key: dgw_live_your_key_here

{
  "phone_number": "256771234567",
  "provider": "iotec"           // optional — defaults to "iotec"
}

// Response (200)
{
  "data": {
    "reference": "txn_sub_abc123",
    "status": "pending",
    "amount": 50000,
    "currency": "UGX",
    "provider": "iotec",
    "subscription_id": 5,
    "cycle": 2
  },
  "message": "Subscription charge initiated"
}

// 1. On your backend — create a plan once
const plan = await dgateway("/v1/subscriptions/plans", {
  method: "POST",
  body: { name: "Pro Plan", amount: 50000, currency: "UGX", interval: "monthly" },
});

// 2. When a user subscribes
const sub = await dgateway("/v1/subscriptions", {
  method: "POST",
  body: {
    plan_id: plan.data.id,
    customer_email: user.email,
    customer_name: user.name,
    customer_phone: user.phone,
    start_now: true,
  },
});

// 3. On each billing cycle (cron job or manual trigger)
const charge = await dgateway(`/v1/subscriptions/${sub.data.id}/charge`, {
  method: "POST",
  body: { phone_number: user.phone },
});

// 4. Poll for payment completion
const status = await dgateway("/v1/webhooks/verify", {
  method: "POST",
  body: { reference: charge.data.reference },
});

const DGATEWAY_API = "https://dgatewayapi.desispay.com";
const API_KEY = process.env.DGATEWAY_API_KEY!;

async function collectPayment(amount: number, currency: string, phone: string) {
  const res = await fetch(`${DGATEWAY_API}/v1/payments/collect`, {
    method: "POST",
    headers: {
      "X-Api-Key": API_KEY,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({ amount, currency, phone_number: phone }),
  });
  return res.json();
}

// Usage
const result = await collectPayment(50000, "UGX", "256771234567");
console.log(result.data.reference);