> ## Documentation Index
> Fetch the complete documentation index at: https://docs.payfonte.com/llms.txt
> Use this file to discover all available pages before exploring further.

# FAQ & Features Explained

> Frequently asked questions about Africa payment orchestration, mobile money API integration, MTN MoMo API, M-Pesa API, Airtel Money API, and local payment methods in Africa.

Everything you need to know about Payfonte's payment orchestration platform Africa, mobile money API integration, and processing alternative payment methods (APM) across African markets.

***

## Getting Started

<AccordionGroup>
  <Accordion title="What is Payfonte?" icon="circle-info">
    Payfonte is a payment orchestration platform Africa and mobile money payment aggregator built specifically for African markets. We enable businesses to accept and disburse payments across 14+ African countries through a single payment orchestration API integration.

    Our platform supports all major alternative payment methods (APM) and local payment methods in Africa:

    * Mobile Money API: MTN MoMo, Orange Money, Airtel Money, M-Pesa, Wave, Moov
    * Bank Transfers: Direct bank payments in Nigeria, Kenya, South Africa
    * Cards: Visa, Mastercard via partner gateways
    * Digital Wallets: Opay, PalmPay, and others

    Key Africa mobile money API integrations include:

    * MTN MoMo API integration across 10+ countries
    * M-Pesa API for Kenya and Tanzania
    * Airtel Money API for pan-African coverage
    * Wave Money integration for Senegal, Ivory Coast, and more

    With one multi-PSP integration, you can process payments across all these methods and markets with smart payment routing Africa capabilities.
  </Accordion>

  <Accordion title="How do I get started with Payfonte?" icon="rocket">
    Getting started is simple:

    1. Create a Sandbox Account: Sign up at [sandbox-app.payfonte.com](https://sandbox-app.payfonte.com)
    2. Get API Credentials: Navigate to Settings -> Security ->  API Keys and Webhooks in your dashboard
    3. Set Up Webhooks: Configure your callback URL under Settings -> Security ->  API Keys and Webhooks
    4. Test Your Integration: Use our sandbox environment to test transactions
    5. Complete KYB: Submit documentation via our [KYB form](https://form.jotform.com/240038360690048)
    6. Go Live: Once approved, switch to production credentials

    Typical onboarding time: 1-5 business days after KYB submission.
  </Accordion>

  <Accordion title="What are the differences between Sandbox and Production?" icon="flask">
    | Aspect      | Sandbox                            | Production                 |
    | ----------- | ---------------------------------- | -------------------------- |
    | API URL     | `https://sandbox-api.payfonte.com` | `https://api.payfonte.com` |
    | Dashboard   | `https://sandbox-app.payfonte.com` | `https://app.payfonte.com` |
    | Real Money  | ❌ No                               | ✅ Yes                      |
    | Credentials | Separate sandbox keys              | Separate production keys   |
    | MNO Prompts | Simulated responses                | Real STK push/USSD         |

    <Warning>
      Important: Sandbox and Production are completely separate environments. Your sandbox configuration (API tokens, callback URLs, test data) does NOT carry over to production. You must reconfigure everything when going live.
    </Warning>
  </Accordion>

  <Accordion title="What KYB documents are required for onboarding?" icon="file-contract">
    Our KYB (Know Your Business) requirements vary by business type, but typically include:

    For Companies:

    * Certificate of Incorporation
    * Memorandum & Articles of Association
    * Board Resolution authorizing payment processing
    * Valid ID of Directors/UBOs
    * Proof of Business Address
    * Bank Statement (last 3 months)

    For Sole Proprietors:

    * Business Registration Certificate
    * Valid Government ID
    * Proof of Address
    * Bank Statement

    Processing Time: 1-5 business days

    <Tip>
      We offer relaxed KYB requirements compared to direct MNO integrations. Some merchants have completed onboarding in as little as 5 minutes for straightforward applications.
    </Tip>
  </Accordion>
</AccordionGroup>

***

## Mobile Money API Explained

<AccordionGroup>
  <Accordion title="How does mobile money payment work?" icon="mobile">
    Mobile money is a core alternative payment method (APM) where users pay directly from their mobile wallet (MTN MoMo, M-Pesa, Orange Money, Airtel Money, Wave, etc.) without needing a bank account or card. This is the most popular local payment method in Africa.

    The typical payment flow using our mobile money API:

    ```mermaid theme={null}
    sequenceDiagram
        participant Customer
        participant Merchant
        participant Payfonte
        participant MNO

        Merchant->>Payfonte: Create checkout session
        Payfonte-->>Merchant: Return checkout URL
        Merchant->>Customer: Redirect to checkout
        Customer->>Payfonte: Select mobile money, enter phone
        Payfonte->>MNO: Initiate payment request
        MNO->>Customer: Send STK Push / USSD prompt
        Customer->>MNO: Enter PIN to authorize
        MNO-->>Payfonte: Payment confirmed
        Payfonte->>Merchant: Webhook notification
        Payfonte->>Customer: Redirect to success URL
    ```

    The entire process typically takes 30-60 seconds from initiation to confirmation.
  </Accordion>

  <Accordion title="What is STK Push vs USSD?" icon="code">
    These are two methods MNOs use to prompt customers to authorize payments through their mobile money API:

    ### STK Push (SIM Toolkit Push)

    * How it works: A payment prompt is automatically "pushed" to the customer's phone
    * User experience: Customer sees a pop-up asking them to enter their PIN
    * Supported by: M-Pesa API (Kenya, Tanzania), some MTN markets
    * Pros: Seamless, no dialing required
    * Cons: Requires phone to be on and have signal

    ### USSD (Unstructured Supplementary Service Data)

    * How it works: Customer dials a code or receives a session-based menu
    * User experience: Customer navigates menu and enters PIN
    * Supported by: MTN MoMo API, Orange Money, Airtel Money API
    * Pros: Works on basic phones, no data required
    * Cons: More steps for customer

    ### Provider Authorization (Merchant-Initiated)

    * How it works: Payment request sent directly via mobile money API, MNO prompts customer
    * Supported by: Most alternative payment method providers in West Africa
    * Pros: Consistent experience across channels

    <Note>
      Payfonte's payment orchestration API automatically selects the appropriate authorization method based on the provider and country. You don't need to handle this logic—just call our API and we manage the mobile money integration Africa complexity.
    </Note>
  </Accordion>

  <Accordion title="What is the customer experience for mobile money payments?" icon="user">
    When a customer pays via mobile money through Payfonte:

    Step 1: Initiation

    * Customer selects mobile money as payment method
    * Enters their mobile money phone number
    * Clicks "Pay"

    Step 2: Authorization

    * Customer receives an STK push notification OR USSD prompt on their phone
    * The prompt shows: merchant name, amount, and reference
    * Customer enters their mobile money PIN to authorize

    Step 3: Confirmation

    * Customer sees "Payment Successful" on their phone
    * Receives SMS confirmation from MNO
    * Redirected back to merchant's success page

    Typical Timing:

    | Stage                  | Duration      |
    | ---------------------- | ------------- |
    | Initiation to prompt   | 2-5 seconds   |
    | Customer authorization | 10-30 seconds |
    | Confirmation callback  | 1-3 seconds   |
    | Total                  | 15-45 seconds |
  </Accordion>

  <Accordion title="What is Pre-Authorization for mobile money?" icon="lock">
    Some MNO integrations support pre-authorization, where the customer pre-approves a payment before the merchant initiates it.

    How it works:

    1. Customer visits MNO app/USSD and generates a pre-authorization code
    2. Customer provides this code to the merchant
    3. Merchant includes `preAuthorisationCode` in the API request
    4. Payment is processed without additional prompts

    Supported markets:

    * Orange Burkina Faso
    * Orange Senegal

    <Note>
      Pre-authorization availability depends on the specific MNO and market. Contact support for the latest supported configurations.
    </Note>
  </Accordion>
</AccordionGroup>

***

## Transaction Processing

<AccordionGroup>
  <Accordion title="What transaction statuses can I expect?" icon="traffic-light">
    Payfonte transactions can have the following statuses:

    | Status       | Description                                        | Final? | Action Required   |
    | ------------ | -------------------------------------------------- | ------ | ----------------- |
    | `queued`     | Payment Queued for Processing                      | ❌      | Wait for webhook  |
    | `pending`    | Payment initiated, awaiting customer authorization | ❌      | Wait for webhook  |
    | `processing` | Customer authorized, MNO processing                | ❌      | Wait for webhook  |
    | `success`    | Payment completed successfully                     | ✅      | Fulfill order     |
    | `rejected`   | Payment failed (see error code)                    | ✅      | Show retry option |
    | `failed`     | Payment failed (see error code)                    | ✅      | Show retry option |
    | `expired`    | Customer didn't authorize in time                  | ✅      | Show retry option |
    | `reversed`   | Funds returned to customer                         | ✅      | Update records    |

    <Warning>
      Never fulfill orders based on `pending` or `processing` status. Always wait for a final status (`success`, `failed`, `expired`) before taking action.
    </Warning>
  </Accordion>

  <Accordion title="How does Payfonte ensure 100% final state resolution?" icon="check-double">
    Our Smart Reconciliation Engine ensures every transaction reaches a final status:

    How it works:

    1. Real-time monitoring: We track every transaction from initiation
    2. Automatic polling: For pending transactions, we poll MNO status APIs
    3. Statement reconciliation: We download and reconcile MNO statements
    4. Timeout handling: Transactions that exceed timeout are marked appropriately
    5. Callback retry: We retry webhook notifications until acknowledged or after 60 minute

    Result: No transaction is left in `pending` state indefinitely. Every payment reaches a conclusive status (success, failed, or expired) within the provider's timeout window (typically 5-60 minutes).

    <Tip>
      If you see a transaction stuck in "pending" on your dashboard, our reconciliation engine is already working to resolve it. Check back in 5-60 minutes, or contact support if it persists beyond 60 minutes.
    </Tip>
  </Accordion>

  <Accordion title="What are the timeout windows for different providers?" icon="clock">
    Each MNO has different timeout windows for customer authorization:

    | Provider       | Timeout      | Notes                    |
    | -------------- | ------------ | ------------------------ |
    | M-Pesa (Kenya) | 60 seconds   | STK push expires quickly |
    | MTN MoMo       | 5-15 minutes | Varies by country        |
    | Orange Money   | 5-10 minutes | USSD session timeout     |
    | Airtel Money   | 5-10 minutes | Standard timeout         |
    | Wave           | 5 minutes    | App-based confirmation   |

    If a customer doesn't authorize within the timeout window, the transaction will be marked as `expired` and you'll receive a webhook notification.
  </Accordion>

  <Accordion title="How do I handle failed transactions?" icon="triangle-exclamation">
    When a transaction fails, check the `errorCode` and `errorMessage` in the response/webhook:

    Common failure reasons:

    | Error                  | Cause                                        | Resolution                 |
    | ---------------------- | -------------------------------------------- | -------------------------- |
    | `INSUFFICIENT_FUNDS`   | Customer's wallet balance too low            | Ask customer to top up     |
    | `WRONG_PIN`            | Customer entered incorrect PIN               | Retry with correct PIN     |
    | `TIMEOUT`              | Customer didn't respond in time              | Retry the transaction      |
    | `ACCOUNT_LOCKED`       | Customer's wallet is locked                  | Customer contacts MNO      |
    | `INVALID_PHONE`        | Phone number not registered for mobile money | Verify phone number        |
    | `DAILY_LIMIT_EXCEEDED` | Customer exceeded daily transaction limit    | Try smaller amount or wait |
    | `SYSTEM_ERROR`         | MNO technical issue                          | Retry after a few minutes  |

    Best practices:

    * Show user-friendly error messages
    * Offer retry option for retriable errors
    * Log all failed transactions for analysis
    * Contact support for persistent `SYSTEM_ERROR` issues
  </Accordion>
</AccordionGroup>

***

## Webhooks & Callbacks

<AccordionGroup>
  <Accordion title="How do I set up webhooks?" icon="bell">
    Webhooks notify your server about transaction status changes in real-time.

    Setup steps:

    1. Go to Dashboard → Settings -> Security ->  API Keys and Webhooks
    2. Enter your webhook endpoint URL (e.g., `https://yoursite.com/payfonte/webhook`)
    3. Click Save

    Requirements for your webhook endpoint:

    * Must be publicly accessible (no localhost)
    * Must use HTTPS (SSL certificate required)
    * Must return HTTP 200 within 30 seconds
    * Should be idempotent (handle duplicate calls)

    <Tip>
      You can also specify a webhook URL per-transaction by including the `webhook` parameter in your API request. This overrides the default webhook for that specific transaction.
    </Tip>
  </Accordion>

  <Accordion title="What does a webhook payload look like?" icon="code">
    When a transaction status changes, we send a POST request to your webhook URL:

    ```json theme={null}
    {
      "event": "payment.completed",
      "timestamp": "2025-02-06T10:30:00Z",
      "data": {
        "reference": "ORDER-12345",
        "checkoutId": "chk_abc123xyz",
        "amount": 5000,
        "currency": "NGN",
        "country": "NG",
        "status": "success",
        "provider": "mtn-momo-nigeria",
        "channel": "mobile-money",
        "user": {
          "email": "customer@example.com",
          "phoneNumber": "08012345678"
        },
        "paidAt": "2025-02-06T10:30:00Z",
        "metadata": {
          "orderId": "your-custom-data"
        }
      }
    }
    ```

    Event types:

    * `payment.completed` - Payment successful
    * `payment.failed` - Payment failed
    * `payment.expired` - Payment timed out
    * `disbursement.completed` - Disbursement successful
    * `disbursement.failed` - Disbursement failed
  </Accordion>

  <Accordion title="How should I handle webhooks?" icon="server">
    Best practices for webhook handling:

    ```javascript theme={null}
    app.post('/payfonte/webhook', async (req, res) => {
      const event = req.body;

      // 1. Acknowledge immediately (prevents timeout)
      res.status(200).send('OK');

      // 2. Process asynchronously
      processWebhookAsync(event);
    });

    async function processWebhookAsync(event) {
      // 3. Check if already processed (idempotency)
      const existing = await db.findTransaction(event.data.reference);
      if (existing?.status === event.data.status) {
        return; // Already processed
      }

      // 4. Verify transaction via API (optional but recommended)
      const verified = await payfonte.verifyTransaction(event.data.reference);

      // 5. Update your records
      await db.updateTransaction(event.data.reference, {
        status: verified.status,
        paidAt: verified.paidAt
      });

      // 6. Take action
      if (verified.status === 'success') {
        await fulfillOrder(event.data.reference);
      }
    }
    ```

    <Warning>
      Critical: Always return HTTP 200 quickly. If your endpoint times out or returns an error, we'll retry the webhook. Implement idempotency to handle duplicate deliveries.
    </Warning>
  </Accordion>

  <Accordion title="What if my webhook endpoint is down?" icon="server">
    We implement automatic retry logic for failed webhook deliveries:

    Retry schedule:

    * Attempt 1: Immediate
    * Attempt 2: 1 minute later
    * Attempt 3: 5 minutes later
    * Attempt 4: 30 minutes later
    * Attempt 5: 1 hours later

    After all retries fail:

    * Transaction status is still updated in our system
    * You can always query transaction status via API
    * Replay the webhooks from your dashboard

    <Tip>
      Set up monitoring for your webhook endpoint and dashboard alerts for failed deliveries. You can also implement a polling fallback to check for missed webhooks.
    </Tip>
  </Accordion>
</AccordionGroup>

***

## Settlement & Disbursements

<AccordionGroup>
  <Accordion title="How quickly do I receive my funds?" icon="money-bill-transfer">
    Settlement times vary by country and payment method:

    | Country        | Method        | Settlement              |
    | -------------- | ------------- | ----------------------- |
    | Nigeria        | Bank Transfer | T+1 (Next business day) |
    | Nigeria        | Mobile Money  | T+1 to T+2              |
    | Kenya          | M-Pesa        | T+1                     |
    | Ghana          | All methods   | T+1 to T+2              |
    | Ivory Coast    | Mobile Money  | T+2 to T+3              |
    | Other CFA Zone | Mobile Money  | T+2 to T+3              |

    T = Settlement Request Day

    Settlements are processed to your designated bank account or mobile money wallet as configured in your merchant profile.
  </Accordion>

  <Accordion title="Can I send Disbursements (disbursements)?" icon="paper-plane">
    Yes! Payfonte supports disbursements to:

    * Mobile Money Wallets: Send to any supported MNO
    * Bank Accounts: Nigeria, Kenya, South Africa, and more
    * Bulk Disbursements: Process multiple disbursements in one API call

    Process:

    1. Validate recipient (phone number or bank account)
    2. Submit disbursement request
    3. Receive webhook on completion

    Typical processing times:

    * Mobile Money: 30 seconds - 5 minutes
    * Bank Transfer: Same day - Next business day

    See our [Disbursements Guide](/en/guides/disbursements/overview) for full documentation.
  </Accordion>

  <Accordion title="How do I check my wallet balance?" icon="wallet">
    You can check your wallet balances via:

    Dashboard:

    * Login to your merchant dashboard
    * View balances on the home screen
    * You can switch country by using the switch on the top right to view balances in a different country

    API:

    ```bash theme={null}
    curl --location 'https://api.payfonte.com/billing/v1/wallets' \
      --header 'client-id: YOUR_CLIENT_ID' \
      --header 'client-secret: YOUR_CLIENT_SECRET'
    ```

    Response shows balances per currency:

    ```json theme={null}
    {
      "data": [
        { "currency": "NGN", "country": "NG", "balance": 1500000 },
        { "currency": "KES", "country": "KE", "balance": 85000 },
        { "currency": "XOF", "country": "CI", "balance": 2500000 }
      ]
    }
    ```
  </Accordion>
</AccordionGroup>

***

## Technical Integration - Payment Orchestration API

<AccordionGroup>
  <Accordion title="How should I format amounts?" icon="hashtag">
    Payfonte does not support decimal amounts. Send integer values only in minor units.

    Examples:

    | Display Amount | Value to Send |
    | -------------- | ------------- |
    | `5000.50 NGN`  | `500050`      |
    | `100.00 GHS`   | `10000`       |
    | `1000 KES`     | `100000`      |
    | `10000 XOF`    | `1000000`     |
    | `5000 XAF`     | `500000`      |

    <Warning>
      Important: Sending decimals (for example `1250.75`) will cause validation or provider failures. Send minor-unit integers only (for example `125075`).
    </Warning>

    See [Amount Specification](/en/guides/introductions/amount-specification) for full conversion guidance, and [Supported Providers](/en/guides/introductions/supported-providers) for provider limits.
  </Accordion>

  <Accordion title="How should I format phone numbers?" icon="phone">
    Phone numbers should be in international format without the plus sign:

    | Country     | Format        | Example         |
    | ----------- | ------------- | --------------- |
    | Nigeria     | 234XXXXXXXXXX | `2348012345678` |
    | Kenya       | 254XXXXXXXXX  | `254712345678`  |
    | Ghana       | 233XXXXXXXXX  | `233201234567`  |
    | Ivory Coast | 225XXXXXXXXXX | `2250512345678` |
    | Cameroon    | 237XXXXXXXXX  | `237612345678`  |

    Do NOT include:

    * Plus sign (+)
    * Spaces or dashes
    * Leading zeros after country code

    Example:

    ```json theme={null}
    // ✅ Correct
    { "phoneNumber": "2348012345678" }

    // ❌ Wrong
    { "phoneNumber": "+234-801-234-5678" }
    { "phoneNumber": "08012345678" }
    ```
  </Accordion>

  <Accordion title="What is the Direct Charge API?" icon="bolt">
    The Direct Charge payment orchestration API allows you to initiate payments directly without redirecting customers to a checkout page. This is useful for:

    * Server-to-server payments: When you've already collected customer details for mobile money API charges
    * Recurring payments: Charging saved payment methods
    * Mobile app integrations: Native mobile money integration Africa experiences

    How it works with MTN MoMo API, M-Pesa API, and other mobile money:

    ```bash theme={null}
    curl --location 'https://api.payfonte.com/payments/v1/payments/direct-charge' \
      --header 'client-id: YOUR_CLIENT_ID' \
      --header 'client-secret: YOUR_CLIENT_SECRET' \
      --header 'Content-Type: application/json' \
      --data '{
        "provider": "mtn-momo-nigeria",
        "amount": 5000,
        "reference": "ORDER-12345",
        "customerInput": {
          "phoneNumber": "2348012345678"
        },
        "webhook": "https://yoursite.com/webhook"
      }'
    ```

    The customer receives the STK push / USSD prompt directly on their phone through the Africa mobile money API.
  </Accordion>

  <Accordion title="Do you support Hybrid Orchestration (BYOK)?" icon="key">
    Yes! Bring Your Own Keys (BYOK) or Hybrid Orchestration is our multi-PSP integration Africa approach that lets you use your existing MNO contracts through Payfonte's payment orchestration platform infrastructure.

    How it works:

    * You maintain direct contracts with MNOs (e.g., MTN MoMo API, M-Pesa API, Orange Money)
    * Securely input your MNO’s API keys, this gets tokenised and stored encrypted and not visible to Payfonte
    * We route transactions through your MNO wallet/account/OVA using our smart payment routing engine
    * You keep your negotiated rates for each mobile money API

    Benefits of multi-PSP integration:

    * Lower fees (your negotiated rates)
    * Maintain provider relationships
    * Combined coverage (your contracts + our partnerships)
    * Single dashboard for all alternative payment methods (APM)
    * Enterprise payment orchestration Africa capabilities

    Setup:
    Contact [commercial@payfonte.com](mailto:commercial@payfonte.com) to configure hybrid orchestration for your Africa payment orchestration account.
  </Accordion>

  <Accordion title="What happens if a provider is down?" icon="server">
    Payfonte's smart payment routing Africa technology provides automatic failover:

    How it works:

    1. When a primary provider fails, we automatically try backup rails
    2. Multi-PSP integration ensures multiple providers per country for redundancy
    3. Real-time monitoring detects outages within seconds
    4. Traffic is re-routed without merchant intervention

    Example for mobile money API failover:

    * Primary: MTN MoMo API direct integration
    * Backup 1: MTN via aggregator
    * Backup 2: Alternative mobile money payment aggregator route

    Result: 99.99% uptime and higher transaction success rates across all local payment methods in Africa.

    <Note>
      You can also configure routing preferences in your dashboard if you want to prioritize certain alternative payment methods for cost or performance reasons.
    </Note>
  </Accordion>
</AccordionGroup>

***

## Security & Compliance

<AccordionGroup>
  <Accordion title="Is Payfonte PCI DSS compliant?" icon="shield-halved">
    Yes. Payfonte is PCI DSS compliant and undergoes regular security assessments:

    * PCI DSS Compliance: We are strictly compliant with the PCIDSS standard for card security
    * Quarterly ASV Scans: External vulnerability assessments by certified consultants
    * Annual Penetration Testing: Third-party security audits
    * End-to-End Encryption: All data encrypted in transit (TLS 1.2+) and at rest

    You can request our compliance certificates via [compliance@payfonte.com](mailto:compliance@payfonte.com).
  </Accordion>

  <Accordion title="How do you handle customer data privacy?" icon="user-shield">
    We take data privacy seriously:

    * GDPR-aligned practices: Even for non-EU data
    * Data minimization: We only collect what's necessary
    * Encryption: All PII encrypted at rest and in transit
    * Access controls: Role-based access with audit logging
    * Retention policies: Data retained per regulatory requirements

    Customer data we store:

    * Phone numbers (for payment processing)
    * Email addresses (for notifications)
    * Transaction history (for reconciliation)

    We do NOT store:

    * Mobile money PINs
    * Card CVVs (tokenized immediately)
    * Customer wallet balances
  </Accordion>

  <Accordion title="What fraud prevention measures are in place?" icon="magnifying-glass">
    Payfonte includes built-in fraud detection:

    * Velocity checks: Detect unusual transaction patterns
    * Device fingerprinting: Identify suspicious devices
    * Geolocation analysis: Flag location mismatches
    * Amount thresholds: Configurable limits per merchant
    * Blacklist management: Block known bad actors

    You can also:

    * Set custom transaction limits in your dashboard
    * Enable additional verification for high-value transactions
    * Access fraud analytics and reports
  </Accordion>
</AccordionGroup>

***

## Troubleshooting

<AccordionGroup>
  <Accordion title="Why is my transaction stuck in 'pending'?" icon="hourglass">
    Transactions may appear pending for several reasons:

    | Cause                          | Resolution                             |
    | ------------------------------ | -------------------------------------- |
    | Customer hasn't authorized yet | Wait for customer to enter PIN         |
    | MNO processing delay           | Usually resolves within 5-15 minutes   |
    | Network connectivity issues    | Our reconciliation engine will resolve |
    | STK push not received          | Customer may need to retry             |

    What to do:

    1. Wait 5-15 minutes for auto-resolution
    2. Check transaction status via API
    3. If stuck > 30 minutes, contact support

    Our reconciliation engine ensures all transactions reach final state—no manual intervention required in most cases.
  </Accordion>

  <Accordion title="Why am I getting 401 Unauthorized errors?" icon="lock">
    This error means your API credentials are invalid:

    Common causes:

    * Using sandbox credentials with production URL (or vice versa)
    * Typo in `client-id` or `client-secret`
    * Credentials were regenerated and old ones are being used
    * Missing required headers

    Solution:

    1. Verify you're using the correct environment URLs
    2. Re-copy credentials from Dashboard → Settings → API Keys
    3. Ensure headers are exactly: `client-id` and `client-secret` (not `clientId`)

    ```bash theme={null}
    # Correct header format
    --header 'client-id: abc123' \
    --header 'client-secret: xyz789'
    ```
  </Accordion>

  <Accordion title="How do I test different transaction scenarios in sandbox?" icon="flask-vial">
    Our sandbox supports testing various scenarios using test phone numbers.

    [//]: # "| Phone Number | Scenario |"

    [//]: # "|--------------|----------|"

    [//]: # "| `2348000000001` | Successful payment |"

    [//]: # "| `2348000000002` | Failed - Insufficient funds |"

    [//]: # "| `2348000000003` | Failed - Wrong PIN |"

    [//]: # "| `2348000000004` | Timeout - No response |"

    [//]: # "| `2348000000005` | Processing delay (30s) |"

    [//]: #

    [//]: # "Use these numbers with any supported provider slug in sandbox to simulate different outcomes."

    See our [Testing Guide](/en/guides/introductions/testing) for complete test scenarios.
  </Accordion>
</AccordionGroup>

***

## Still Have Questions?

<CardGroup cols={3}>
  <Card title="Contact Support" icon="headset" href="mailto:support@payfonte.com">
    [support@payfonte.com](mailto:support@payfonte.com)
  </Card>

  <Card title="Book a Demo" icon="calendar" href="https://calendly.com/marc-payfonte/30min">
    Schedule a walkthrough
  </Card>

  <Card title="API Reference" icon="code" href="/en/api-reference/introduction">
    Full API documentation
  </Card>
</CardGroup>