One API, 53+ Providers, 200+ Countries

pythondef calculate_provider_score(
    provider: Provider,
    app_config: AppRoutingConfig
) -> float:
    # Real-time success rate (last 24 hours)
    success_weight = 0.35
    success_score = provider.metrics.success_rate_24h

    # Average latency (lower is better)
    latency_weight = 0.20
    latency_score = 1.0 - min(provider.metrics.avg_latency_ms / 10000, 1.0)

    # Transaction cost (lower is better)
    cost_weight = 0.25
    cost_score = 1.0 - min(provider.fee_percent / 5.0, 1.0)

    # Merchant priority (configured in dashboard)
    priority_weight = 0.20
    priority_score = app_config.get_priority(provider.id) / 10.0

    return (
        success_weight * success_score +
        latency_weight * latency_score +
        cost_weight * cost_score +
        priority_weight * priority_score
    )

Request: Pay 5,000 XOF via Orange Money in CI
  |
  +-> Score: Hub2 (0.92) -- PRIMARY
  +-> Score: PaiementPro (0.87) -- FAILOVER 1
  +-> Score: PawaPay (0.81) -- FAILOVER 2
  |
  Hub2 processes successfully -> done
  Hub2 fails (503) -> retry PaiementPro -> success

bash# Node.js / TypeScript
npm install zerofee

# Python
pip install zerofee

# PHP
composer require zerofee/zerofee-php

# Ruby
gem install zerofee

# Go
go get github.com/zerofee/zerofee-go

# Java
// Maven
<dependency>
  <groupId>dev.zerofee</groupId>
  <artifactId>zerofee-java</artifactId>
  <version>1.0.0</version>
</dependency>

# C#
dotnet add package ZeroFee

typescriptimport { ZeroFee } from 'zerofee';

const zf = new ZeroFee({
  apiKey: process.env.ZEROFEE_API_KEY!,
  environment: 'live'  // or 'test'
});

// 1. Create a payment
const payment = await zf.payments.create({
  amount: 25_00,          // $25.00 in cents
  currency: 'USD',
  country: 'US',
  method: 'PAYIN_CARD',
  customer: {
    email: '[email protected]',
    name: 'John Doe'
  },
  metadata: {
    orderId: 'order_12345',
    productName: 'Pro Plan'
  },
  returnUrl: 'https://yourapp.com/payment/success',
  cancelUrl: 'https://yourapp.com/payment/cancel'
});

console.log(payment.checkoutUrl);
// -> https://checkout.0fee.dev/pay_abc123

// 2. Check payment status
const status = await zf.payments.get(payment.id);
console.log(status.status);
// -> 'pending' | 'completed' | 'failed' | 'expired'

// 3. Issue a refund
const refund = await zf.refunds.create({
  paymentId: payment.id,
  amount: 25_00,  // full refund
  reason: 'Customer requested cancellation'
});

pythonfrom zerofee import ZeroFee

zf = ZeroFee(api_key="zf_live_...")

# Create an Orange Money payment in Ivory Coast
payment = zf.payments.create(
    amount=10000,           # 10,000 XOF
    currency="XOF",
    country="CI",
    method="PAYIN_ORANGE_CI",
    customer={"phone": "+2250700112233"},
    metadata={"invoice_id": "INV-2026-001"},
    return_url="https://yourapp.com/callback"
)

print(f"Payment ID: {payment.id}")
print(f"Status: {payment.status}")
# Customer receives USSD push on their phone

# List recent payments with filtering
payments = zf.payments.list(
    country="CI",
    status="completed",
    limit=50,
    offset=0
)

for p in payments.data:
    print(f"{p.id}: {p.amount} {p.currency} - {p.status}")

typescriptimport express from 'express';
import { ZeroFee } from 'zerofee';

const app = express();
const zf = new ZeroFee({ apiKey: process.env.ZEROFEE_API_KEY! });

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

  try {
    const event = zf.webhooks.verify(req.body, signature);

    switch (event.type) {
      case 'payment.completed':
        // Fulfill the order
        fulfillOrder(event.data.metadata.orderId);
        break;

      case 'payment.failed':
        // Notify the customer
        notifyPaymentFailed(event.data.customer.email);
        break;

      case 'refund.completed':
        // Update order status
        markOrderRefunded(event.data.paymentId);
        break;
    }

    res.status(200).json({ received: true });
  } catch (err) {
    console.error('Webhook verification failed:', err);
    res.status(400).json({ error: 'Invalid signature' });
  }
});

bash# 1. Install the SDK
npm install zerofee

# 2. Get your API key at dashboard.0fee.dev

# 3. Start accepting payments

typescriptimport { ZeroFee } from 'zerofee';

const zf = new ZeroFee({ apiKey: 'zf_test_...' });

// Accept a payment from anywhere in the world
const payment = await zf.payments.create({
  amount: 1000,
  currency: 'USD',
  country: 'US',
  method: 'PAYIN_CARD',
  customer: { email: '[email protected]' },
  returnUrl: 'https://localhost:3000/success'
});

console.log(`Checkout: ${payment.checkoutUrl}`);