Build with Elicate Pay

{
  "amount": 50.00,
  "phone": "0962000000",
  "network": "MTN",
  "currency": "ZMW",
  "reference": "ORDER-12345",
  "customer_name": "John Banda"
}

{
  "transaction_id": "EP-M4K2F9-A1B2",
  "status": "pending",
  "reference": "ORDER-12345",
  "meta": {
    "authorization": {
      "mode": "redirect",
      "redirect_url": "https://flutterwave.com/verify/redirect/xyz..."
    },
    "message": "Customer must complete verification. If redirect mode, open the redirect_url in an iframe or new tab."
  }
}

{
  "transaction_id": "EP-M4K2F9-A1B2",
  "status": "redirect",
  "reference": "CART-789",
  "meta": {
    "authorization": {
      "mode": "redirect",
      "redirect_url": "https://flutterwave.com/verify/redirect/xyz..."
    },
    "message": "Customer must complete verification. If redirect mode, open the redirect_url in an iframe or new tab."
  }
}

{
  "transaction_id": "EP-M4K2F9-A1B2",
  "status": "pending",
  "amount": 100.00,
  "currency": "ZMW",
  "reference": "ORDER-12345"
}

{
  "transaction_id": "EP-M4K2F9-A1B2",
  "status": "success",
  "amount": 100.00,
  "fee": 2.50,
  "net_amount": 97.50,
  "currency": "ZMW",
  "reference": "ORDER-12345",
  "customer_name": "John Banda",
  "customer_phone": "0962000000",
  "network": "MTN",
  "created_at": 1710000000000,
  "updated_at": 1710000060000
}

const response = await fetch(
  'https://elicatepay.vercel.app/api/v1/payments/EP-XXX/stream',
  { headers: { 'Authorization': 'Bearer ep_test_sk_...' } }
);
const reader = response.body.getReader();
const decoder = new TextDecoder();
while (true) {
  const { done, value } = await reader.read();
  if (done) break;
  console.log(decoder.decode(value));
  // event: payment.success
  // data: {"transaction_id":"EP-XXX","status":"success","amount":100,...}
}

{
  "payment_links": [
    {
      "id": "abc123firebaseDocId",
      "name": "Pro Plan Subscription",
      "type": "fixed",
      "amount": 299,
      "min_amount": 0,
      "description": "Monthly subscription",
      "redirect_url": "https://mysite.com/thanks",
      "active": true,
      "slug": "a1b2c3d4",
      "url": "https://elicatepay.vercel.app/pay/a1b2c3d4",
      "created_at": 1710000000000
    }
  ],
  "total": 1
}

{
  "name": "Donation",
  "type": "flexible",
  "min_amount": 10,
  "description": "Support our cause",
  "redirect_url": "https://mysite.com/thankyou"
}

{
  "id": "abc123firebaseDocId",
  "name": "Donation",
  "type": "flexible",
  "amount": 0,
  "min_amount": 10,
  "description": "Support our cause",
  "redirect_url": "https://mysite.com/thankyou",
  "active": true,
  "slug": "x9y8z7w6",
  "url": "https://elicatepay.vercel.app/pay/x9y8z7w6",
  "created_at": 1710000000000
}

{
  "name": "Updated Name",
  "active": false
}

{
  "event": "payment.success",
  "data": {
    "transaction_id": "EP-M4K2F9-A1B2",
    "reference": "ORDER-12345",
    "amount": 100.00,
    "fee": 2.50,
    "net_amount": 97.50,
    "currency": "ZMW",
    "customer_name": "John Banda",
    "customer_phone": "0962000000",
    "network": "MTN",
    "status": "success"
  }
}

const crypto = require('crypto');

function verifyWebhook(rawBody, signature, secret) {
  const expected = crypto
    .createHmac('sha256', secret)
    .update(rawBody)
    .digest('hex');
  return crypto.timingSafeEqual(
    Buffer.from(signature),
    Buffer.from(expected)
  );
}

// Express middleware
app.post('/webhook', express.raw({ type: 'application/json' }), (req, res) => {
  const sig = req.headers['x-elicatepay-signature'];
  const rawBody = req.body.toString();

  if (!verifyWebhook(rawBody, sig, 'your-webhook-secret')) {
    return res.status(401).send('Invalid signature');
  }

  const { event, data } = JSON.parse(rawBody);
  if (event === 'payment.success') {
    // Fulfill the order
  }
  res.status(200).send('OK');
});

{
  "url": "https://your-server.com/webhook",
  "secret": "your-webhook-secret"
}

{
  "status": "delivered",
  "httpStatus": 200
}

<iframe src={redirectUrl} width="100%" height="420" style={{ borderRadius: 12, border: '1px solid #eee' }} />

const express = require('express');
const crypto = require('crypto');
const app = express();

const SECRET_KEY = 'ep_test_sk_your_key_here';
const BASE = 'https://elicatepay.vercel.app';
const WH_SECRET = 'your-webhook-secret';

// 1. Charge a customer
app.post('/pay', express.json(), async (req, res) => {
  const { phone, network, amount, name } = req.body;

  const response = await fetch(`${BASE}/api/v1/payments/charge`, {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${SECRET_KEY}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      amount, phone, network,
      customer_name: name,
      reference: `ORDER-${Date.now()}`,
    }),
  });

  const data = await response.json();
  if (!response.ok) return res.status(response.status).json({ error: data.error });

  // Save data.transaction_id with your order in your database
  res.json({ message: 'Check your phone to approve', transaction_id: data.transaction_id });
});

// 2. Receive webhooks
app.post('/webhook', express.raw({ type: 'application/json' }), (req, res) => {
  const sig = req.headers['x-elicatepay-signature'];
  const raw = req.body.toString();
  const expected = crypto.createHmac('sha256', WH_SECRET).update(raw).digest('hex');

  if (!crypto.timingSafeEqual(Buffer.from(sig || ''), Buffer.from(expected))) {
    return res.status(401).send('Invalid signature');
  }

  const { event, data } = JSON.parse(raw);
  if (event === 'payment.success') {
    console.log(`Payment ${data.transaction_id} succeeded! Net: ${data.net_amount} ZMW`);
    // Mark order as paid in your database
  }
  res.status(200).send('OK');
});

app.listen(3001);

import requests, hmac, hashlib
from flask import Flask, request, jsonify

app = Flask(__name__)

SECRET_KEY = "ep_test_sk_your_key_here"
BASE = "https://elicatepay.vercel.app"
WH_SECRET = "your-webhook-secret"

@app.route("/pay", methods=["POST"])
def pay():
    data = request.get_json()
    resp = requests.post(
        f"{BASE}/api/v1/payments/charge",
        headers={"Authorization": f"Bearer {SECRET_KEY}", "Content-Type": "application/json"},
        json={
            "amount": data["amount"],
            "phone": data["phone"],
            "network": data["network"],
            "customer_name": data.get("name", "Customer"),
        },
    )
    result = resp.json()
    if resp.status_code != 200:
        return jsonify({"error": result.get("error")}), resp.status_code
    return jsonify({"message": "Check your phone", "transaction_id": result["transaction_id"]})

@app.route("/webhook", methods=["POST"])
def webhook():
    sig = request.headers.get("X-ElicatePay-Signature", "")
    raw = request.get_data(as_text=True)
    expected = hmac.new(WH_SECRET.encode(), raw.encode(), hashlib.sha256).hexdigest()
    if not hmac.compare_digest(sig, expected):
        return "Invalid signature", 401
    payload = request.get_json()
    if payload["event"] == "payment.success":
        print(f"Payment {payload['data']['transaction_id']} succeeded!")
    return "OK", 200

<?php
$SECRET_KEY = 'ep_test_sk_your_key_here';
$BASE = 'https://elicatepay.vercel.app';

function charge(float $amount, string $phone, string $network): array {
    global $SECRET_KEY, $BASE;
    $ch = curl_init("$BASE/api/v1/payments/charge");
    curl_setopt_array($ch, [
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_POST => true,
        CURLOPT_HTTPHEADER => [
            "Authorization: Bearer $SECRET_KEY",
            'Content-Type: application/json',
        ],
        CURLOPT_POSTFIELDS => json_encode([
            'amount' => $amount,
            'phone' => $phone,
            'network' => $network,
        ]),
    ]);
    $res = curl_exec($ch);
    curl_close($ch);
    return json_decode($res, true);
}

// webhook.php — verify and handle
$raw = file_get_contents('php://input');
$sig = $_SERVER['HTTP_X_ELICATEPAY_SIGNATURE'] ?? '';
$expected = hash_hmac('sha256', $raw, 'your-webhook-secret');
if (!hash_equals($expected, $sig)) { http_response_code(401); exit('Bad sig'); }
$payload = json_decode($raw, true);
if ($payload['event'] === 'payment.success') {
    // Mark order as paid
}
http_response_code(200);

'use client';
import { useState } from 'react';

export default function CheckoutForm({ publicKey }: { publicKey: string }) {
  const [phone, setPhone] = useState('');
  const [network, setNetwork] = useState('MTN');
  const [status, setStatus] = useState<'idle'|'loading'|'pending'|'success'|'failed'>('idle');

  async function handlePay() {
    setStatus('loading');
    const res = await fetch('https://elicatepay.vercel.app/api/v1/checkout/pay', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({
        public_key: publicKey,
        customer_name: 'Customer',
        phone, network,
        amount: 100,
      }),
    });
    const data = await res.json();
    if (!res.ok) { alert(data.error); setStatus('idle'); return; }

    setStatus('pending');
    // Poll for result
    const poll = setInterval(async () => {
      const s = await fetch(`https://elicatepay.vercel.app/api/v1/checkout/status/${data.transaction_id}`);
      const st = await s.json();
      if (st.status === 'success') { clearInterval(poll); setStatus('success'); }
      if (st.status === 'failed')  { clearInterval(poll); setStatus('failed'); }
    }, 3000);
    setTimeout(() => clearInterval(poll), 120000);
  }

  return (
    <div>
      <input placeholder="Phone" value={phone} onChange={e => setPhone(e.target.value)} />
      <select value={network} onChange={e => setNetwork(e.target.value)}>
        <option>MTN</option><option>AIRTEL</option><option>ZAMTEL</option>
      </select>
      <button onClick={handlePay} disabled={status==='loading'||status==='pending'}>
        {status==='pending' ? 'Waiting...' : 'Pay K100'}
      </button>
      {status==='success' && <p>Payment successful!</p>}
      {status==='failed' && <p>Payment failed.</p>}
    </div>
  );
}