const res = await fetch('https://api.bursapay.com/api/v1/payments/initialize/', {
  method: 'POST',
  headers: { 'Authorization': 'Bearer sk_test_your_key_here', 'Content-Type': 'application/json' },
  body: JSON.stringify({ amount: 5000, email: 'john@example.com' }),
});
const data = await res.json();
console.log(data);

const axios = require('axios');
const { data } = await axios.post(
  'https://api.bursapay.com/api/v1/payments/initialize/',
  { amount: 5000, email: 'john@example.com' },
  { headers: { Authorization: 'Bearer sk_test_your_key_here' } }
);
console.log(data);

$ch = curl_init('https://api.bursapay.com/api/v1/payments/initialize/');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true, CURLOPT_POST => true,
  CURLOPT_POSTFIELDS => json_encode(['amount' => 5000, 'email' => 'john@example.com']),
  CURLOPT_HTTPHEADER => ['Authorization: Bearer sk_test_your_key_here', 'Content-Type: application/json']
]);
print_r(json_decode(curl_exec($ch), true));

const headers: Record<string, string> = {
  Authorization: 'Bearer sk_test_your_key_here',
  'Content-Type': 'application/json',
};
const res = await fetch('https://api.bursapay.com/api/v1/payments/initialize/', {
  method: 'POST', headers, body: JSON.stringify({ amount: 5000, email: 'john@example.com' })
});
const data = await res.json();

curl -X POST https://api.bursapay.com/api/v1/payments/initialize/ \
  -H "Authorization: Bearer sk_test_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{"amount":5000,"email":"john@example.com"}'

curl -X POST https://api.bursapay.com/api/v1/payments/initialize/ \
  -H "Authorization: Bearer sk_test_xxxx" \
  -H "Content-Type: application/json" \
  -d '{"amount":5000,"email":"john.doe@example.com"}'

curl -X POST https://api.bursapay.com/api/v1/payments/verify/ \
  -H "Authorization: Bearer sk_test_xxxx" \
  -H "Content-Type: application/json" \
  -d '{"reference":"BP-xxx"}'

fetch('https://api.bursapay.com/api/v1/payments/BP-xxx/', {
  headers: { 'Authorization': 'Bearer sk_test_xxxx' }
})
.then(res => res.json())
.then(console.log);

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://api.bursapay.com/api/v1/payments/BP-xxx/");
curl_setopt($ch, CURLOPT_HTTPHEADER, array("Authorization: Bearer sk_test_xxxx"));
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$result = curl_exec($ch);
curl_close($ch);
echo $result;

curl -X POST https://api.bursapay.com/api/v1/payment-intents/ \
  -H "Authorization: Bearer sk_test_xxxx" \
  -H "Content-Type: application/json" \
  -d '{"amount":15000,"email":"customer@example.com","capture_method":"manual"}'

const response = await fetch('https://api.bursapay.com/api/v1/payment-intents/', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer sk_test_xxxx',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    amount: 15000,
    email: 'customer@example.com',
    capture_method: 'manual'
  })
});
const data = await response.json();
console.log(data);

resp = requests.post(
    "https://api.bursapay.com/api/v1/payment-intents/PI-3M8V182A/capture/",
    json={"amount_to_capture": 15000},
    headers={"Authorization": "Bearer sk_test_xxxx"}
)
print(resp.json()["data"]["status"]) # succeeded

import requests

headers = {"Authorization": "Bearer sk_test_xxxx"}
data = {"customer_reference": "CUST-123", "amount": 5000, "authorization_code": "AUTH-xyz"}
response = requests.post("https://api.bursapay.com/api/v1/payments/charge/", headers=headers, json=data)
print(response.json())

fetch('https://api.bursapay.com/api/v1/payments/charge/', {
  method: 'POST',
  headers: { 'Authorization': 'Bearer sk_test_xxxx', 'Content-Type': 'application/json' },
  body: JSON.stringify({ customer_reference: "CUST-123", amount: 5000, authorization_code: "AUTH-xyz" })
})
.then(res => res.json())
.then(console.log);

const fetch = require('node-fetch');

fetch('https://api.bursapay.com/api/v1/payments/bulk/', {
  method: 'POST',
  headers: { 'Authorization': 'Bearer sk_test_xxxx', 'Content-Type': 'application/json' },
  body: JSON.stringify({ payments: [{ amount: 1000, customer_reference: "CUST-1" }] })
})
.then(res => res.json())
.then(console.log);

curl -X POST https://api.bursapay.com/api/v1/payments/bulk/ \
  -H "Authorization: Bearer sk_test_xxxx" \
  -H "Content-Type: application/json" \
  -d '{"payments":[{"amount":1000,"customer_reference":"CUST-1"}]}'

fetch('https://api.bursapay.com/api/v1/customers/', {
  method: 'POST',
  headers: { 'Authorization': 'Bearer sk_test_xxxx', 'Content-Type': 'application/json' },
  body: JSON.stringify({ email: "test@example.com", name: "Test User" })
})
.then(res => res.json())
.then(console.log);

fetch('https://api.bursapay.com/api/v1/customers/CUST-abc/', {
  headers: { 'Authorization': 'Bearer sk_test_xxxx' }
})
.then(res => res.json())
.then(console.log);

curl -X POST https://api.bursapay.com/api/v1/customers/import/ \
  -H "Authorization: Bearer sk_test_xxxx" \
  -F "file=@customers.csv;type=text/csv"

const form = new FormData();
form.append('file', csvBlob, 'customers.csv');

fetch('https://api.bursapay.com/api/v1/customers/import/', {
  method: 'POST',
  headers: { 'Authorization': 'Bearer sk_test_xxxx' },
  body: form,
})
.then(res => res.json())
.then(console.log);

curl -X GET https://api.bursapay.com/api/v1/wallet/balance/ \
  -H "Authorization: Bearer sk_test_xxxx"

const fetch = require('node-fetch');

fetch('https://api.bursapay.com/api/v1/refunds/', {
  method: 'POST',
  headers: { 'Authorization': 'Bearer sk_test_xxxx', 'Content-Type': 'application/json' },
  body: JSON.stringify({ payment_reference: "BP-xxx", amount: 1000 })
})
.then(res => res.json())
.then(console.log);

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://api.bursapay.com/api/v1/refunds/");
curl_setopt($ch, CURLOPT_POST, 1);
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode(["payment_reference" => "BP-xxx", "amount" => 1000]));
curl_setopt($ch, CURLOPT_HTTPHEADER, array("Authorization: Bearer sk_test_xxxx", "Content-Type: application/json"));
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$result = curl_exec($ch);
curl_close($ch);
echo $result;

fetch('https://api.bursapay.com/api/v1/refunds/REF-xyz/', {
  headers: { 'Authorization': 'Bearer sk_test_xxxx' }
})
.then(res => res.json())
.then(console.log);

curl -X GET https://api.bursapay.com/api/v1/refunds/REF-xyz/ \
  -H "Authorization: Bearer sk_test_xxxx"

const crypto = require('crypto');

function verifyWebhook(payload, signature, secret) {
    const hash = crypto.createHmac('sha512', secret).update(payload).digest('hex');
    return hash === signature;
}

function verifyWebhook($payload, $signature, $secret) {
    $expected = hash_hmac('sha512', $payload, $secret);
    return hash_equals($expected, $signature);
}

import (
    "crypto/hmac"
    "crypto/sha512"
    "encoding/hex"
)

func VerifyWebhook(payload []byte, signature, secret string) bool {
    h := hmac.New(sha512.New, []byte(secret))
    h.Write(payload)
    expected := hex.EncodeToString(h.Sum(nil))
    return expected == signature
}

require 'openssl'

def verify_webhook(payload, signature, secret)
  expected = OpenSSL::HMAC.hexdigest('SHA512', secret, payload)
  expected == signature
end

import * as crypto from 'crypto';

export function verifyWebhook(payload: string, signature: string, secret: string): boolean {
    const hash = crypto.createHmac('sha512', secret).update(payload).digest('hex');
    return hash === signature;
}

fetch('https://api.bursapay.com/api/v1/webhooks/', {
  method: 'POST',
  headers: { 'Authorization': 'Bearer sk_test_xxxx', 'Content-Type': 'application/json' },
  body: JSON.stringify({ url: "https://myapp.com/webhook", events: ["payment.success"] })
})
.then(res => res.json())
.then(console.log);

curl -X POST https://api.bursapay.com/api/v1/webhooks/ \
  -H "Authorization: Bearer sk_test_xxxx" \
  -H "Content-Type: application/json" \
  -d '{"url":"https://myapp.com/webhook","events":["payment.success"]}'

import requests

response = requests.get("https://api.bursapay.com/api/v1/health/")
print(response.json())

const { data } = await axios.post(
  'https://api.bursapay.com/api/v1/transfers/',
  {
    amount: 5000, bank_code: '058',
    account_number: '0123456789', account_name: 'Chidi Okeke',
    narration: 'Vendor payment — Invoice #1042',
  },
  {
    headers: {
      Authorization: 'Bearer sk_live_xxxx',
      'Idempotency-Key': 'unique-key-per-transfer-001'
    }
  }
);

curl -X POST https://api.bursapay.com/api/v1/transfers/ \
  -H "Authorization: Bearer sk_live_xxxx" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: unique-transfer-key-001" \
  -d '{"amount":5000,"bank_code":"058","account_number":"0123456789","account_name":"Chidi Okeke"}'

curl https://api.bursapay.com/api/v1/transfers/ -H "Authorization: Bearer sk_live_xxxx"
curl https://api.bursapay.com/api/v1/transfers/TRF-xxxx/ -H "Authorization: Bearer sk_live_xxxx"

const { data } = await (await fetch('https://api.bursapay.com/api/v1/payment-links/', {
  method: 'POST',
  headers: { 'Authorization': 'Bearer sk_test_xxxx', 'Content-Type': 'application/json' },
  body: JSON.stringify({ amount: 180000, title: 'Invoice #1042' })
})).json();
console.log(data.checkout_url);

curl -X POST https://api.bursapay.com/api/v1/payment-links/ \
  -H "Authorization: Bearer sk_test_xxxx" \
  -H "Content-Type: application/json" \
  -d '{"amount":180000,"title":"Invoice #1042"}'

const { data } = await (await fetch('https://api.bursapay.com/api/v1/payment-links/bulk/', {
  method: 'POST',
  headers: { 'Authorization': 'Bearer sk_test_xxxx', 'Content-Type': 'application/json' },
  body: JSON.stringify([
    { title: 'Invoice #1001', amount: 50000 },
    { title: 'Invoice #1002', amount: 75000 },
  ])
})).json();
data.forEach(link => console.log(link.link_code, link.checkout_url));

curl -X POST https://api.bursapay.com/api/v1/payment-links/bulk/ \
  -H "Authorization: Bearer sk_test_xxxx" \
  -H "Content-Type: application/json" \
  -d '[{"title":"Invoice #1001","amount":50000},{"title":"Invoice #1002","amount":75000}]'

const res = await fetch('https://api.bursapay.com/api/v1/analytics/?period=30d¤cy=NGN', {
  headers: { 'Authorization': 'Bearer sk_live_xxxx' }
});
const { data } = await res.json();
console.log(`Volume: ${data.total_volume}, Transactions: ${data.transaction_count}`);

curl "https://api.bursapay.com/api/v1/analytics/?period=30d¤cy=NGN" \
  -H "Authorization: Bearer sk_live_xxxx"

const BASE = 'https://api.bursapay.com/api/v1';
const headers = { 'Authorization': 'Bearer sk_live_xxxx', 'Content-Type': 'application/json' };

// Attach fulfillment proof
const res = await fetch(`${BASE}/payments/BP-abc123/fulfillment/`, {
  method: 'PUT',
  headers,
  body: JSON.stringify({
    delivery_url: 'https://example.com/delivery/receipt-456',
    delivery_confirmed_at: '2025-01-15T10:30:00Z',
    service_description: 'SaaS subscription — annual plan',
    proof_of_delivery: 'Customer activated on 2025-01-15.'
  })
});
const data = await res.json();
console.log(data);

curl -X PUT "https://api.bursapay.com/api/v1/payments/BP-abc123/fulfillment/" \
  -H "Authorization: Bearer sk_live_xxxx" \
  -H "Content-Type: application/json" \
  -d '{
    "delivery_url": "https://example.com/delivery/receipt-456",
    "delivery_confirmed_at": "2025-01-15T10:30:00Z",
    "service_description": "SaaS subscription — annual plan",
    "proof_of_delivery": "Customer activated on 2025-01-15."
  }'

const res = await fetch('https://api.bursapay.com/api/v1/sandbox/seed/', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer sk_test_xxxx',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({ scenario: 'high_volume' })
});
const data = await res.json();
console.log(data.data.created); // { payments: 100, customers: 20 }

curl -X POST "https://api.bursapay.com/api/v1/sandbox/seed/" \
  -H "Authorization: Bearer sk_test_xxxx" \
  -H "Content-Type: application/json" \
  -d '{"scenario": "disputes"}'

const res = await fetch('https://api.bursapay.com/api/v1/sandbox/seed/', {
  method: 'DELETE',
  headers: { 'Authorization': 'Bearer sk_test_xxxx' }
});
const data = await res.json();
console.log(`Deleted ${data.data.deleted} records`);

curl -X DELETE "https://api.bursapay.com/api/v1/sandbox/seed/" \
  -H "Authorization: Bearer sk_test_xxxx"

import asyncio
from bursapay import BursaPay

async def main():
    async with BursaPay("sk_test_xxxx").async_client() as bp:
        payment = await bp.payments.initialize(amount=5000, email="a@b.com")
        result = await bp.payments.verify(payment["reference"])
        balance = await bp.wallets.balance()

asyncio.run(main())

from bursapay import BursaPay

is_valid = BursaPay.verify_webhook_signature(
    request.body,
    request.headers.get("X-BursaPay-Signature", ""),
    "your_webhook_secret"
)
if not is_valid:
    raise PermissionError("Invalid signature")

import json
from django.http import HttpResponse
from django.views.decorators.csrf import csrf_exempt
from bursapay import BursaPay

@csrf_exempt
def bursapay_webhook(request):
    is_valid = BursaPay.verify_webhook_signature(
        request.body, request.headers.get("X-BursaPay-Signature", ""), "secret"
    )
    if not is_valid:
        return HttpResponse(status=401)
    event = json.loads(request.body)
    return HttpResponse(status=200)

from fastapi import FastAPI, Request, HTTPException
from bursapay import BursaPay

app = FastAPI()

@app.post("/hooks/bursapay/")
async def bursapay_webhook(request: Request):
    body = await request.body()
    sig = request.headers.get("X-BursaPay-Signature", "")
    if not BursaPay.verify_webhook_signature(body, sig, "secret"):
        raise HTTPException(status_code=401)
    return {"status": "ok"}

import { BursaPay, Payment, Currency } from 'bursapay-sdk';

const bp = new BursaPay(process.env.BURSAPAY_SECRET_KEY!);

const payment: Payment = await bp.payments.initialize({
  amount: 5000,
  email: 'customer@example.com',
  currency: 'NGN' satisfies Currency
});

import { BursaPayInline } from 'bursapay-sdk';

BursaPayInline.checkout({
  publicKey: 'pk_live_xxxx',
  reference: 'BP-XXXX',
  email: 'customer@example.com',
  onSuccess: (ref) => { window.location.href = `/confirm?ref=${ref}`; }
});

import express from 'express';
import { BursaPay } from 'bursapay-sdk';

const app = express();
app.post('/hooks/bursapay', express.raw({ type: '*/*' }), async (req, res) => {
  const ok = await BursaPay.verifyWebhookSignature(req.body, req.headers['x-bursapay-signature'], process.env.WEBHOOK_SECRET);
  if (!ok) return res.sendStatus(401);
  res.sendStatus(200);
});

import { NextRequest, NextResponse } from 'next/server';
import { BursaPay } from 'bursapay-sdk';

export async function POST(request: NextRequest) {
  const raw = Buffer.from(await request.arrayBuffer());
  const sig = request.headers.get('x-bursapay-signature') ?? '';
  const ok = await BursaPay.verifyWebhookSignature(raw, sig, process.env.WEBHOOK_SECRET!);
  if (!ok) return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
  return NextResponse.json({ received: true });
}

<?php
namespace App\Http\Controllers;

use Illuminate\Http\Request;
use BursaPay\Resources\Webhooks;
use BursaPay\Exceptions\SignatureVerificationException;

class WebhookController extends Controller
{
    public function handle(Request $request)
    {
        $payload = $request->getContent();
        $sig = $request->header('X-BursaPay-Signature', '');
        $ts = $request->header('X-BursaPay-Timestamp', '');
        $secret = config('services.bursapay.webhook_secret');

        try {
            $event = Webhooks::constructEvent($payload, $sig, $ts, $secret);
            if ($event['event'] === 'payment.success') {
                // Fulfill order...
            }
            return response()->json(['status' => 'ok']);
        } catch (SignatureVerificationException $e) {
            return response()->json(['error' => $e->getMessage()], 400);
        }
    }
}

<?php
use BursaPay\Resources\Webhooks;

$payload = file_get_contents('php://input');
$sig = $_SERVER['HTTP_X_BURSAPAY_SIGNATURE'] ?? '';
$ts = $_SERVER['HTTP_X_BURSAPAY_TIMESTAMP'] ?? '';
$secret = getenv('BURSAPAY_WEBHOOK_SECRET');

$isValid = Webhooks::verifySignature($payload, $sig, $ts, $secret);
if (!$isValid) {
    http_response_code(400);
    exit('Invalid signature');
}

package main

import (
	"io"
	"net/http"
	"os"

	"github.com/bursapay/bursapay-go"
)

func webhookHandler(w http.ResponseWriter, r *http.Request) {
	payload, err := io.ReadAll(r.Body)
	if err != nil {
		http.Error(w, "Bad request", http.StatusBadRequest)
		return
	}

	sig := r.Header.Get("X-BursaPay-Signature")
	ts := r.Header.Get("X-BursaPay-Timestamp")
	secret := os.Getenv("BURSAPAY_WEBHOOK_SECRET")

	event, err := bursapay.ConstructEvent(payload, sig, ts, secret)
	if err != nil {
		http.Error(w, "Invalid signature: "+err.Error(), http.StatusBadRequest)
		return
	}

	if event.Event == "payment.success" {
		// Fulfill order...
	}
	w.WriteHeader(http.StatusOK)
}

package main

import (
	"log"

	"github.com/bursapay/bursapay-go"
)

func verifyPayload(body []byte, sig, ts, secret string) {
	err := bursapay.VerifySignature(body, sig, ts, secret, 300)
	if err != nil {
		log.Fatalf("Webhook signature invalid: %v", err)
	}
	log.Println("Signature verified successfully!")
}

import { BursaPay, ValidationError, AuthenticationError, RateLimitError } from 'bursapay-sdk';

try {
  const payment = await bp.payments.initialize({ amount: 5000, email: 'x@y.com' });
} catch (err) {
  if (err instanceof ValidationError) {
    console.log(err.errorCode, err.fieldErrors);
  } else if (err instanceof AuthenticationError) {
    console.log('Invalid key');
  } else if (err instanceof RateLimitError) {
    await new Promise(r => setTimeout(r, 2000));
  }
}

<?php
use BursaPay\Exceptions\AuthenticationException;
use BursaPay\Exceptions\InvalidRequestException;
use BursaPay\Exceptions\RateLimitException;
use BursaPay\Exceptions\BursaPayException;

try {
    $payment = $bursapay->payments->initialize(['amount' => 5000, 'email' => 'x@y.com']);
} catch (AuthenticationException $e) {
    echo "Auth error: " . $e->getMessage();
} catch (InvalidRequestException $e) {
    echo "Validation error: " . $e->getMessage();
} catch (RateLimitException $e) {
    echo "Rate limited. Retry later.";
} catch (BursaPayException $e) {
    echo "API Error: " . $e->getMessage();
}

package main

import (
	"context"
	"errors"
	"fmt"

	"github.com/bursapay/bursapay-go"
)

func main() {
	client := bursapay.NewClient("sk_test_xxxx")
	_, err := client.Payments.Initialize(context.Background(), &bursapay.PaymentInitRequest{Amount: 5000})

	var authErr *bursapay.AuthenticationError
	var invalidErr *bursapay.InvalidRequestError
	var rateErr *bursapay.RateLimitError

	if errors.As(err, &authErr) {
		fmt.Println("Auth failed:", authErr.Error())
	} else if errors.As(err, &invalidErr) {
		fmt.Println("Invalid input:", invalidErr.Error())
	} else if errors.As(err, &rateErr) {
		fmt.Println("Rate limit exceeded:", rateErr.Error())
	}
}