DEV Community: SeerBit Developers

Integrating SeerBit Payments in Angular

FOLASAYO SAMUEL OLAYEMI — Mon, 23 Jun 2025 15:46:35 +0000

SeerBit offers a powerful Angular library (seerbit-angular) that makes adding secure payment modals super easy. You can integrate as either a Component or Directive, depending on your design preference and styling needs.

Prerequisites

Make sure you have:

Angular v16 or newer
A SeerBit merchant account and valid public key

Step 1: Install the Library

npm install --save seerbit-angular

Step 2: Import the Module

In your AppModule:

import { BrowserModule } from '@angular/platform-browser';
import { NgModule } from '@angular/core';
import { NgSeerBitModule } from 'seerbit-angular';

import { AppComponent } from './app.component';

@NgModule({
  declarations: [AppComponent],
  imports: [BrowserModule, NgSeerBitModule],
  bootstrap: [AppComponent]
})
export class AppModule {}

This makes SeerBit’s component and directive available in your templates.

Quick Tip: Need `app.module.ts`? Create a Module-Based Project

If you've noticed your project is missing app.module.ts, it's likely because you're using Angular 17+, where standalone components are the default. You can switch to a module-based structure by running:

ng new my-app --no-standalone --routing --ssr=false

This creates a traditional setup with app.module.ts and app-routing.module.ts, letting you copy over any existing code into a familiar module architecture. There’s no automatic way to convert, so if AppModule is missing and you haven’t written much code yet, this is the simplest route.

Step 3: Set Up Your Component Logic

In app.component.ts:

import { Component } from '@angular/core';

@Component({
  selector: 'app-root',
  templateUrl: './app.component.html',
  styleUrls: ['./app.component.css']
})
export class AppComponent {
  title = 'seerbit-angular-integration';

  options = {
    tranref: Date.now(),
    currency: 'NGN',
    description: 'Test payment',
    country: 'NG',
    email: 'you@example.com',
    mobile_no: '08012345678',
    full_name: 'Jane Doe',
    amount: 5000,
    setAmountByCustomer: false,
    close_prompt: false,
    close_on_success: false,
    callbackurl: 'https://yourapp.com/payment-callback',
    public_key: 'YOUR_PUBLIC_KEY_HERE',
    customization: {
      theme: { border_color: '#000', background_color: '#004C64', button_color: '#0084A0' },
      payment_method: ['card', 'transfer', 'wallet', 'ussd'],
      display_fee: true,
      logo: 'your_logo_url_or_base64'
    },
    tokenize: false,
    planId: ''
  };

  PaymentDone(res: any) {
    console.log('Payment done:', res.response);
    res.closeModal();
  }

  PaymentCancel(res: any) {
    console.log('Payment cancelled:', res);
  }
}

Customize the options object with your merchant key and shopper info.

Step 4: Add the UI

As a Component

In app.component.html:

<main>
  <div class="content">
    <h1>SeerBit Angular Payment</h1>
    <seerbit-ng
      class="btn-pay"
      [options]="options"
      (callback)="PaymentDone($event)"
      (close)="PaymentCancel($event)">
      Pay Now
    </seerbit-ng>
  </div>
</main>

As a Directive

<main>
  <div class="content">
    <h1>Pay with SeerBit</h1>
    <button
      class="btn-pay"
      seerbit-ng
      [options]="options"
      (callback)="PaymentDone($event)"
      (close)="PaymentCancel($event)">
      Pay via SeerBit
    </button>
  </div>
</main>

Component vs directive is up to your styling preferences. Just ensure CSS is global if you need to style the custom element.

Step 5: Add Some Basic CSS

In styles.css (global):

.btn-pay {
  display: inline-block;
  padding: 0.75rem 1.5rem;
  background-color: #0084A0;
  color: white;
  border: none;
  border-radius: 0.25rem;
  font-size: 1rem;
  cursor: pointer;
  text-align: center;
}

.btn-pay:hover {
  background-color: #006f88;
}

Component-scoped CSS won’t apply to seerbit-ng, so use global styles for classes used on it.

Step 6: Run & Test

Start your app:

ng serve

Navigate to http://localhost:4200/, click your button, and test the payment flow. Check your console logs for PaymentDone or PaymentCancel.

Bonus: Shopping Cart Demo

The SeerBit GitHub repo includes a full shopping cart example: both directive and component versions integrated within a cart UI. It’s a great reference for real‑world use.

Summary

Integration Type	Tag Used	Good For
Component	`<seerbit-ng>`	When you want modal style
Directive	`seerbit-ng` on `<button>`	For custom buttons / styling

Download the source code here

Thanks for reading...
Happy Coding!

Implementing SeerBit Payment Solution in a Full-Stack Application Using ReactJS and NodeJS

FOLASAYO SAMUEL OLAYEMI — Tue, 10 Jun 2025 08:35:22 +0000

In today’s digital economy, seamless and secure payment integration is a must-have for any modern web application. SeerBit, a leading African fintech company, offers powerful APIs that enable businesses to accept payments with ease.

This article will guide you step-by-step on how to integrate SeerBit's payment solution into a ReactJS + NodeJS full-stack application.

By the end of this guide, you’ll have working knowledge of:

Setting up SeerBit API credentials
Creating a payment interface with ReactJS
Handling transactions securely using NodeJS
Best practices for production-ready integration

Whether you're building an eCommerce site, SaaS product, or mobile wallet, this tutorial gives you a powerful and flexible foundation for collecting payments via SeerBit.

Prerequisites

Before we start, ensure you have the following:

Node.js and npm installed
Basic knowledge of React and Node
A SeerBit account (sign up at seerbit.com)
API Keys from your SeerBit dashboard
Postman (optional, for testing APIs)

Project Setup

1. Initialize the Backend (NodeJS)

mkdir seerbit-payment-backend
cd seerbit-payment-backend
npm init -y
npm install express cors dotenv axios

Create a basic server.js:

// server.js
const express = require("express");
const cors = require("cors");
const dotenv = require("dotenv");
const axios = require("axios");

dotenv.config();
const app = express();

app.use(cors());
app.use(express.json());

const PORT = process.env.PORT || 5000;

app.listen(PORT, () => console.log(`Server running on port ${PORT}`));

2. Create the Frontend (ReactJS)

npx create-react-app seerbit-payment-frontend
cd seerbit-payment-frontend
npm install axios

Step 1: Get Your SeerBit API Keys

Log in to SeerBit Dashboard.
Navigate to API Keys (usually under Settings → API Keys).
Copy your Public Key and Secret Key

Create a .env file in your backend folder:

SEERBIT_SECRET_KEY=your_secret_key_here
SEERBIT_PUBLIC_KEY=your_public_key_here
SEERBIT_BEARER_TOKEN=generate_the_token_with_secret_key_&_pub_key

Generating the Bearer Token
To integrate SeerBit's payment services into your Node.js application, you'll need to generate a bearer token for API authentication.

SeerBit requires an encrypted key, derived from your secret and public keys, to authenticate API requests.

Follow these steps to generate the bearer token:

Public Key: Obtain this from your SeerBit merchant dashboard.
Secret Key: Also available on your merchant dashboard.
Concatenate and Encrypt Keys: Combine your secret and public keys into a single string, separated by a period (.)
Encryption: Send this concatenated string to SeerBit's encryption endpoint to receive an encrypted key.

Request the Encrypted Key:

Endpoint: POST https://seerbitapi.com/api/v2/encrypt/keys

Headers: Set Content-Type to application/json.

Body: Include the concatenated key in the following JSON format:

{
 "key": "SECRET_KEY.PUBLIC_KEY"
}

Step 2: Create Payment Route in NodeJS

Add the following to server.js or create a new file paymentRoutes.js:

const express = require("express");
const cors = require("cors");
const dotenv = require("dotenv");
const { Client, Config, StandardCheckout } = require("seerbit-nodejs");
const { PUBLIC_KEY, SECRET_KEY, BEARER_TOKEN } = require("./config");

// Load environment variables
dotenv.config();

const app = express();
app.use(cors({ origin: "http://localhost:3000", credentials: true }));
app.use(express.json());

// Create SeerBit client
const sdkConfig = new Config({
  publicKey: PUBLIC_KEY,
  secretKey: SECRET_KEY,
  bearerToken: BEARER_TOKEN,
});

const seerbit = new Client(sdkConfig);

// Payment endpoint
app.post("/api/payment", async (req, res) => {
  try {
    const checkout = new StandardCheckout(seerbit);
    const { email, amount, fullName, mobile_no, description } = req.body;
    // Create payment
    const payload = {
      amount,
      currency: "NGN",
      country: "NG",
      email,
      fullName,
      mobile_no,
      description,
      paymentReference: `ref-${Date.now()}`,
      callbackUrl: "http://localhost:3000/payment-success",
    };

    const response = await checkout.Initialize(payload);
    console.log("SeerBit SDK response:", response);
    const payLink = response.data.payments.redirectLink;
    console.log("Payment Link Only Returned:", payLink);
    return res.status(201).json({ payLink });
  } catch (error) {
    console.error("SeerBit SDK error:", error);
    return res.status(error.status || 500).json({ error: error.message });
  }
});

// Start server
const PORT = process.env.PORT || 9000;
app.listen(PORT, () => console.log(`Server running on port ${PORT}`));

Click this link to learn how to integrate SeerBit Payments using Node.js

Step 3: Create the Payment Interface in ReactJS

Edit App.js:

import React, { useState, useEffect } from "react";
import axios from "axios";

function App() {
  const [form, setForm] = useState({
    fullName: "",
    email: "",
    amount: "",
    mobile_no: "",
    description: "",
  });
  const [loading, setLoading] = useState(false);
  const [error, setError] = useState(null);

  const handleChange = (e) => {
    setForm({ ...form, [e.target.name]: e.target.value });
  };

  const handleSubmit = async (e) => {
    e.preventDefault();
    setLoading(true);
    setError(null);

    try {
      // Use proxy or full URL as needed
      const response = await axios.post("/api/payment", form);
      const payLink = response.data.payLink;
      console.log("Redirecting to:", payLink.data);
      console.log("Log the response:", response);
      if (payLink) {
        window.location.href = payLink;
      } else {
        setError("Payment link unavailable");
      }
    } catch (err) {
      console.error("Payment initiation failed", err);
      setError(err.response?.data?.error || "Unknown error occurred");
    } finally {
      setLoading(false);
    }
  };

  return (
    <div
      style={{ maxWidth: 400, margin: "2rem auto", fontFamily: "sans-serif" }}
    >
      <h2>SeerBit Payment</h2>
      <form onSubmit={handleSubmit}>
        <label>
          Full Name
          <br />
          <input
            name="fullName"
            value={form.fullName}
            onChange={handleChange}
            required
          />
        </label>
        <br />
        <br />
        <label>
          Email
          <br />
          <input
            type="email"
            name="email"
            value={form.email}
            onChange={handleChange}
            required
          />
        </label>
        <br />
        <label>
          Phone Number
          <br />
          <input
            type="mobile_no"
            name="mobile_no"
            value={form.mobile_no}
            onChange={handleChange}
            required
          />
        </label>
        <br />
        <br />
        <label>
          Description
          <br />
          <input
            type="description"
            name="description"
            value={form.description}
            onChange={handleChange}
            required
          />
        </label>
        <br />
        <br />
        <label>
          Amount (NGN)
          <br />
          <input
            type="number"
            name="amount"
            value={form.amount}
            onChange={handleChange}
            required
          />
        </label>
        <br />
        <br />
        <button type="submit" disabled={loading}>
          {loading ? "Processing..." : "Pay Now"}
        </button>
      </form>

      {error && (
        <p style={{ color: "red", marginTop: "1rem" }}>Error: {error}</p>
      )}
    </div>
  );
}

export default App;

Step 4: Test the Integration

Run the backend:

node server.js

Run the frontend:

npm start

Fill in the form and click Pay with SeerBit

You will be redirected to SeerBit's secure payment gateway.

Download the source code here...

Best Practices for Production

Use https and host your backend securely
Validate all inputs both client-side and server-side
Store transactions and references in your database
Use webhook support to verify payments server-to-server
Rate limit your API endpoints to prevent abuse

Conclusion

With SeerBit's powerful APIs and simple integration process, developers can launch secure, user-friendly payment experiences in days, not weeks. Whether you're building for Nigeria or across Africa, SeerBit offers the tools and infrastructure to help your application grow.

Have questions or want to connect? Reach out to me on LinkedIn.

Resources

Did you enjoy this tutorial? Share it with your dev friends, bookmark it, and build the next big fintech app using SeerBit.

Thanks for reading...
Happy Coding!

How to Easily Integrate the SeerBit Payment Solution with React.js

FOLASAYO SAMUEL OLAYEMI — Mon, 26 May 2025 07:12:03 +0000

Integrating the SeerBit ReactJS SDK into your application is straightforward—even for beginners.

This guide walks you step by step through obtaining your Public Key, installing prerequisites, configuring environment variables, and using the SDK both as a React Hook and as a prebuilt Button component. By following best practices for secure key management, and error handling, you’ll be able to accept payments seamlessly in minutes.

Introduction

SeerBit’s seerbit-reactjs package provides a React-specific wrapper for SeerBit’s payment gateway, enabling you to embed payment flows with minimal code. It abstracts away raw HTTP calls, encryption, and error parsing—letting you focus on building your UI and business logic without wrestling with low‑level API details.

Prerequisites

Before integrating, ensure you have:

Node.js v12+ installed on your machine. You can download it from the official site.
A SeerBit Merchant Account with both Public and Secret keys.
Basic React knowledge and familiarity with npm or yarn package managers.

Step 1: Obtain Your Public Key

Log in to the SeerBit Dashboard with your merchant credentials.
Navigate to API Keys (usually under Settings → API Keys).
Copy your Public Key.

Tip: Store these keys securely—never hard‑code them in your source.

Step 2: Install the SDK

In your React project directory, run:

npm install --save seerbit-reactjs
# or
yarn add seerbit-reactjs

The package includes TypeScript definitions for better autocomplete in modern editors.

Step 3: Configure Environment Variables

Create a .env file at your project root (add to .gitignore):

REACT_APP_SEERBIT_PUBLIC_KEY=SBTESTPUBK_xxx

Load them in src/config.js:

export const PUBLIC_KEY = process.env.REACT_APP_SEERBIT_PUBLIC_KEY;

This isolates sensitive data and supports multiple environments.

Step 4: Using the SDK as a React Hook

Import the Hook:

   import { useSeerbitPayment } from "seerbit-reactjs";
   import { PUBLIC_KEY } from "./config";

Define your payment options:

   const options = {
     public_key: PUBLIC_KEY,
     amount: 5000,
     tranref: Date.now().toString(),
     currency: "NGN",
     email: "customer@example.com",
     full_name: "Jane Doe",
     mobile_no: "08012345678",
     description: "Order #1234",
     tokenize: false,
     customization: {
       theme: {
         border_color: "#000000",
         background_color: "#004C64",
         button_color: "#0084A0",
       },
       payment_method: ["card", "account", "transfer", "wallet", "ussd"],
       display_fee: true,
       display_type: "inline",
       logo: "https://yourdomain.com/logo.png",
     },
   };

Set up callback and close handlers:

   const callback = (response, close) => {
     console.log("Payment successful:", response);
     setTimeout(() => close(), 2000);
   };
   const close = () => console.log("Checkout closed");

Initialize the payment:

   const initializePayment = useSeerbitPayment(options, callback, close);

Trigger on user action:

   <button onClick={initializePayment}>Pay Now</button>

Result: Clicking the button opens SeerBit’s checkout, handles the flow, and returns the response to your callback.

Step 5: Using the Prebuilt Button Component

For minimal setup, use SeerbitButton:

Import the component:

   import { SeerbitButton } from "seerbit-reactjs";
   import { PUBLIC_KEY } from "./config";

Prepare options and handlers:

   const callback = (res, close) => { console.log(res); close(); };
   const close = () => console.log("Closed");
   const props = { ...options, callback, close };

Render the button:

   <SeerbitButton text="Pay with SeerBit" {...props} className="btn-pay" />

Result: A fully styled button that launches the checkout flow on click.

Download source code here.

Step 6: Testing Your Integration

Local Testing: Run npm start to launch your app and click the Pay button.
Sandbox Mode: Use your test keys to simulate transactions without real charges.
Monitoring: Check network calls in your browser’s DevTools to inspect the payload and response.

Error Handling & Logging

Wrap your payment initialization in try…catch:

try {
  await initializePayment();
} catch (error) {
  console.error("SeerBit Error:", error.code, error.message);
}

Use a structured logger (e.g., Winston) for production-level monitoring.

Best Practices

Secure Key Storage: Keep keys in env vars, rotate regularly.
Version Pinning: Lock seerbit-reactjs in package.json to prevent breaking updates.
CI/CD: Automate linting (ESLint), type checks, and integration tests on pull requests.
Graceful Fallback: Implement retries and user-friendly error messages for network failures.

Conclusion

By following these steps—obtaining your keys, installing the SDK, configuring securely, and using either the Hook or Button component—you can integrate SeerBit payments into your React app quickly and reliably. Happy coding!

References

SeerBit ReactJS SDK GitHub: https://github.com/seerbit/seerbit-reactjs
SeerBit Official Docs: https://doc.seerbit.com/libraries-plugins/sdks
SeerBit Dashboard Login: https://www.dashboard.seerbit.com/#/auth/login
NPM Package “seerbit-reactjs”: https://www.npmjs.com/package/seerbit-reactjs
Managing Environment Variables in Create React App: https://create-react-app.dev/docs/adding-custom-environment-variables
Winston Logging Library: https://www.npmjs.com/package/winston
React Error Boundaries: https://www.npmjs.com/package/react-error-boundary

Thanks for reading...
Happy Coding!

INTEGRATING SEERBIT NODE.JS SDK IN YOUR APPLICATION

FOLASAYO SAMUEL OLAYEMI — Mon, 12 May 2025 10:19:10 +0000

This tutorial provides a detailed explanation on how to integrate SeerBit’s NodeJS SDK into your applications. And also, you will learn how to install and set up the NodeJS SDL, implement standard and advanced payment functions, handle errors gracefully, test your integrations, and apply optimal approaches for reliable, efficient code. We also include working code samples and screenshots of transaction responses and explain each integration step to make sure you can follow along easily, even if you have no idea how to work with payment APIs.

Introduction

SeerBit’s NodeJS SDK was built so developers could easily interact with SeerBit’s payment APIs in their NodeJS projects. The SDK offers support for standard checkout, recurring payments, pre-auth, mobile money. This abstracts from the raw HTTP calls, encryption details, and error parsing, which allows developers to focus on business logic rather than low-level API wiring.

Prerequisites

Make sure you have NodeJS v10+ installed on your machine.
SeerBit account with public and secret keys; you can obtain this from your merchant dashboard when you sign in.
Basic knowledge of JavaScript and npm/yarn.

Installation

Install via npm or Yarn in your project directory:

npm install --save seerbit-nodejs  

# or  

yarn add seerbit-nodejs

The package includes TypeScript definitions for autocompletion in modern editors.

Generating the Bearer Token

To integrate SeerBit's payment services into your Node.js application, you'll need to generate a bearer token for API authentication.

SeerBit requires an encrypted key, derived from your secret and public keys, to authenticate API requests.

Follow these steps to generate the bearer token:
1.Prepare Your Keys:

Public Key: Obtain this from your SeerBit merchant dashboard.
Secret Key: Also available on your merchant dashboard.

2.Concatenate and Encrypt Keys:
Format: Combine your secret and public keys into a single string, separated by a period (.):

SECRET_KEY.PUBLIC_KEY

Encryption: Send this concatenated string to SeerBit's encryption endpoint to receive an encrypted key.

Request the Encrypted Key:
Endpoint: POST https://seerbitapi.com/api/v2/encrypt/keys Headers: Set Content-Type to application/json.

Body: Include the concatenated key in the following JSON format:

{
  "key": "SECRET_KEY.PUBLIC_KEY"
}

Important Considerations:

Security: Handle your secret and public keys with care. Avoid exposing them in client-side code or public repositories.
Token Validity: The encryptedKey (bearer token) may have a validity period. Ensure you handle token expiration appropriately in your application.
Error Handling: Implement comprehensive error handling to manage potential issues during the token generation and payment initialization processes.

For detailed information, refer to SeerBit's official documentation on authentication and the Node.js SDK:

Authentication: https://apis.seerbit.com/authentication

Node.js SDK: https://github.com/seerbit/seerbit-nodejs

Configuration

Create a config.js to centralize your keys (never commit .env to source control):

require('dotenv').config();

module.exports = {

  PUBLIC_KEY: process.env.SEERBIT_PUBLIC_KEY,

  SECRET_KEY: process.env.SEERBIT_SECRET_KEY,

  BEARER_TOKEN: process.env.SEERBIT_BEARER_TOKEN

};

Load and initialize the SDK in your application:

// app.js

const { Client, Config } = require("seerbit-nodejs");

const { PUBLIC_KEY, SECRET_KEY, BEARER_TOKEN } = require("./config");

const sdkConfig = new Config({ publicKey: PUBLIC_KEY, secretKey: SECRET_KEY, bearerToken: BEARER_TOKEN });

const seerbit = new Client(sdkConfig);

This setup ensures keys remain secure and easily swappable across environments.

Basic Usage Examples

Standard Checkout Flow

const { StandardCheckout } = require("seerbit-nodejs");

router.post("/standard-checkout", async (req, res, next) => {
  try {
    const checkout = new StandardCheckout(seerbit);
    const { fullName, amount, currency, country, email } = req.body;
    const payload = {
      fullName,
      amount,      currency,
      country,
      email,
      paymentReference: Date.now().toString(),
      callbackUrl: "https://yourapp.com/callback",
    };
    const response = await checkout.Initialize(payload);
    return res.status(201).json({ response });
  } catch (error) {
    console.error("Checkout Error:", error);
    return next(error);
  }
});

This prints a JSON similar to:

{

  "status": "success",

  "data": {

    "paymentLink": "https://payments.seerbit.com/checkout/abc123",

    "paymentStatus": "01"
    "message":"Successful"

  }

}

1.Test the Endpoint with Curl/Postman
To get the response above, you can test the standard checkout endpoint with curl or Postman. We use Curl as an example.

2.Checkout UI
Copy the payment link and load it on your browser to proceed with the payment. Input your debit/credit card details to proceed with the transaction, or make payment via other suggested options:

After inputting your card details, you will be prompted to input your card PIN and OTP to verify the transaction. If you have entered all these details correctly, you will get a response of a successful transaction modal that pops up.

Advanced Features

Recurring Payments For the recurring payment, set the tokenized state to true:

const { StandardCheckout } = require("seerbit-nodejs");

router.post("/standard-checkout", async (req, res, next) => {
  try {
    const checkout = new StandardCheckout(seerbit);
    const { fullName, amount, currency, country, email } = req.body;
    const payload = {
      fullName,
      amount,
      currency,
      country,
      email,
      paymentReference: Date.now().toString(),
      callbackUrl: "https://yourapp.com/callback",
      tokenize: true
    };
    const response = await checkout.Initialize(payload);
    return res.status(201).json({ response });
  } catch (error) {
    console.error("Checkout Error:", error);
    return next(error);
  }
});

This creates a plan that you can later subscribe customers to automatically.

Debit/credit card payment is the only option allowed for recurring payment. This will save the input card details for recurring charges.

2.Mobile Money Payment
Change the country code and currency to match the country of choice.

Note: Our mobile money payment is only available in the following countries at the point of writing this article (Ghana, Kenya, and South Africa).

Error Handling and Logging

Wrap calls in try…catch and inspect error.code / error.message:

try {

  await checkout.Initialize(payload);

} catch (err) {

  console.error("SeerBit Error", err.code, err.message);

}

Use a structured logger like Winston to record failures and facilitate debugging in production.

Best Practices

Secure Key Management: store API keys in environment variables; rotate regularly.
Version Pinning: lock seerbit-nodejs version in package.json to avoid breaking changes.
CI/CD: run linting (ESLint), tests, and vulnerability scans on every pull request.
Graceful Degradation: Implement retries with exponential backoff for transient network errors.

Conclusion

By following this guide, you’ve set up SeerBit’s NodeJS SDK, performed standard and advanced payment flows, and implemented robust error handling.

For more details, visit the SeerBit Developer Documentations or explore the GitHub repo.

Thanks for reading...
Happy Coding!

Earn with Ease: Introducing the SeerBit Partner Dashboard

FOLASAYO SAMUEL OLAYEMI — Wed, 05 Mar 2025 14:42:35 +0000

Imagine a platform where you can actively or passively earn commissions simply by inviting businesses or developers to process payments.
Enter the SeerBit Partner Dashboard—a revolutionary tool designed to empower individuals and organizations while creating a seamless pathway to generate income. Whether you’re a business owner, developer, or affiliate marketer, this dashboard opens a world of earning opportunities tied to successful transactions.

What is the SeerBit Partner Dashboard?

The SeerBit Partner Dashboard is your gateway to earning commissions by referring businesses or developers to SeerBit's payment platform. Every successful transaction processed by your invitees rewards you with either active or passive commissions, depending on your involvement. It’s a win-win model—your network enjoys secure, reliable payment processing, and you gain a steady income stream.

How Does It Work?

Sign Up and Get Started: Register for a SeerBit Partner account and gain access to your personalized dashboard by filling this form.
Invitation Email: After completing the form, you will receive an invitation email containing your registered email address and a temporary password. Click on the highlighted link labeled Profile Setup Link to proceed.

Reset Password: You will be asked to reset your password by entering your email. Use the email you provided during registration to receive the OTP for resetting your password.

Change Your Password Using OTP: An OTP will be sent to your email to help you securely change your temporary password.

Create a new password: Set a new password by replacing the temporary password generated for you.

After successfully setting your new password, you should receive the response shown below:
Fill in the KYC form: After successfully creating a new password, you will be redirected to complete the KYC form, as shown below:
Enter your Email information: When prompted to enter your email information, you will need to provide the following types of email addresses:

Business Email:
This is your primary email address used for official communication with clients, partners, or stakeholders. It represents your business and is often associated with your domain (e.g., info@yourbusiness.com). Ensure this email is active and monitored regularly, as it will be used for important business-related correspondence.
Support Email:
The support email is dedicated to handling customer inquiries and issues. It’s often shared with your customers as the main point of contact for customer service or technical support (e.g., support@yourbusiness.com). This email helps you separate customer interactions from other business communications, ensuring timely responses to customer needs.
Chargeback Email:
This email is specifically used for managing disputes or chargebacks related to transactions. It’s where notifications about refunds, payment disputes, or issues with transactions are sent (e.g., chargebacks@yourbusiness.com). Keeping this email separate ensures these critical notifications don’t get lost in general correspondence.
Settlement Information: Settlement refers to the process of transferring funds from SeerBit to your bank account.

Once you have completed the settlement form, you will be redirected to your partner dashboard, where you can begin inviting businesses to transact under your account.

Conclusion

In conclusion, setting up your account on the SeerBit platform is a straightforward process designed to get you up and running as a partner in no time. By providing accurate settlement details and completing the necessary forms, you unlock access to your partner dashboard, where you can manage and grow your business network seamlessly. With the ability to invite businesses to transact under your account, the opportunities to expand your reach and revenue are endless.

Take the next step today and leverage the power of SeerBit to simplify payments and drive business growth!

Thanks for reading...
Happy Coding!

SeerBit Enhanced Merchant Services

FOLASAYO SAMUEL OLAYEMI — Wed, 05 Mar 2025 12:43:32 +0000

Most businesses face many issues of transactions restriction between Africans, restrained bank infrastructures, and other cross-border transactions difficulties.

SeerBit is a payment gateway that provides solution to this problem, by offering secure payment platform that bridges the gaps between merchants and their customers, by driving financial inclusion.
SeerBit provides payment solutions that helps businesses to scale at every stage of their business, and helps businesses of any size in Africa to collect and manage payments seamlessly, and to provide value to their customers.

OVERVIEW OF SEERBIT MERCHANT DASHBOARD AND INFRASTRUCTURE ENHANCEMENTS FOR MERCHANTS

SeerBit provides comprehensive suite of payment services designed to enhance business efficiency through the merchant dashboard. The merchant dashboard is user friendly, and provide tools that enable merchants to efficiently manage transactions, monitor analytics, and optimize their operations.

These services include:

Checkout: A pre-built payment page that supports multiple payment methods, allowing customers to pay using their preferred options.
Recurring-Payments: Automate repeat payments to streamline subscription-based services.
Payment Links: Generate no-code payment links to facilitate easy and quick payments without the need for a website.
In-Person Payments: Utilize SeerBit's Point-of-Sale (POS) systems to accept payment physically, enhancing in-store payment experiences.
Virtual Accounts: Receive payments via bank transfer into unique virtual account numbers assigned to customers.
Pocket: A wallet management solution that allows businesses to manage funds efficiently within the SeerBit ecosystem.
Smart Invoice: Automatically generate invoices with embedded payment links, enabling customers to make payments directly through the invoice. The system tracks payment statuses in real-time, providing both you and your customers with up-to-date information. This automation streamlines the invoicing process, reduces manual follow-ups, and accelerates payment collection.
Alpha: A payment infrastructure designed to enable businesses to embed a financial services seamlessly.

Strategic Collaborations Amplifying Merchant Services

SeerBit has established strategic partnerships to enhance its merchant services, ensuring businesses have access to comprehensive and efficient payment solutions:

Zoho Partnership: Collaborating with Zoho, a global technology company, SeerBit aims to simplify payment processes for African businesses. This alliance integrates SeerBit's payment solutions with Zoho's cloud-based business software, offering merchants a unified platform to manage operations and transactions seamlessly.
Kuda Collaboration: Teaming up with Kuda, a prominent Nigerian fintech company, SeerBit provides customers with secure, cardless payment options for online transactions. This partnership enhances transaction security and convenience, allowing millions of Kuda users to make payments on SeerBit's platform without entering card details.
Sabre Alliance: In partnership with Sabre, a leading travel technology company, SeerBit is set to revolutionize payment processes within Africa's travel industry. This collaboration aims to streamline payment procedures and boost operational efficiency for airlines, travel agencies, and related service providers.

Merchant Success Stories

SeerBit's commitment to enhancing merchant services is reflected in the success stories of businesses that have benefited from its solutions:

Product Manager's Journey: A SeerBit Product Manager shared her experience in integrating SeerBit's payment solutions with Microsoft Dynamics. This integration has been pivotal in automating payment processes, showcasing SeerBit's dedication to revolutionizing payment systems in Africa and supporting business growth.
Empowering African Businesses: SeerBit's platform has enabled various businesses across Africa to process payments seamlessly, overcoming barriers such as limited internet access and financial services. By providing digital tools tailored to the continent's unique challenges, SeerBit has empowered over 1,000 merchants across eight African countries within 18 months of operation.

Benefits of SeerBit's Initiatives for Merchants and Developers

SeerBit's enhancements offer numerous advantages to both merchants and developers:

For Merchants:

Streamlined Operations: The integrated dashboard allows for efficient management of transactions, reducing administrative burdens.
Expanded Payment Options: Partnerships with platforms like Kuda provide customers with diverse payment methods, potentially increasing sales.
Industry-Specific Solutions: Collaborations with companies like Sabre offer tailored payment solutions for sectors such as travel, enhancing operational efficiency.

For Developers:

Robust APIs: SeerBit provides well-documented APIs, facilitating the integration of payment solutions into various applications.
Continuous Support: Developers benefit from ongoing assistance and updates, ensuring seamless integration and functionality.

Future Outlook

SeerBit is poised to continue its trajectory of innovation and expansion:

Geographical Expansion: Plans are underway to extend services to more African countries, aiming to empower a broader range of businesses with efficient payment solutions.
Technological Advancements: SeerBit is committed to adopting emerging technologies to enhance security, user experience, and transaction speed.
Strengthening Partnerships: The company aims to forge new alliances and strengthen existing ones to diversify and enrich its service offerings.

Conclusion

SeerBit's enhanced merchant services underscore its dedication to transforming the payment landscape in Africa. Through strategic collaborations, technological innovation, and a deep understanding of the unique challenges faced by African businesses, SeerBit continues to empower merchants and developers, fostering growth and efficiency across the continent's diverse markets.

Thanks for reading...
Happy Coding!

Accepting Multiple Currencies with SeerBit: A Developer's Guide

FOLASAYO SAMUEL OLAYEMI — Mon, 17 Feb 2025 15:31:34 +0000

In today's global marketplace, offering multi-currency support is essential for businesses aiming to reach a diverse customer base. Allowing customers to pay in their preferred currency not only enhances user experience but also boosts conversion rates.

SeerBit, a leading payment gateway, provides robust multi-currency capabilities, enabling businesses to seamlessly accept payments from various regions.

SeerBit's Multi-Currency Capabilities

Supported Currencies and Regions

SeerBit supports a wide range of currencies across multiple African countries, including Nigeria, Ghana, Kenya, Senegal, and more. This extensive coverage ensures that businesses can cater to customers in their local currencies, fostering trust and convenience.

Automatic Currency Conversion Features

With SeerBit's intelligent payment routing, transactions are processed through optimal routes, ensuring successful payments. While SeerBit handles multiple currencies, it's essential for developers to manage currency conversions on the client side to display prices accurately to users.

Integrating multi-currency support into your Node.js application using SeerBit enhances your business's global reach by allowing customers to transact in their preferred currencies. This guide provides a step-by-step approach to implementing this functionality, including real-time currency conversion and payment processing with SeerBit's Node.js SDK.

Prerequisites

Before you begin, ensure you have the following:

Node.js and npm: Installed on your development machine.
SeerBit Account: Access to your public and secret keys from the SeerBit dashboard.
API for Exchange Rates: A reliable service like CurrencyFreaks or ExchangeRate-API to fetch real-time exchange rates.

Step 1: Setting Up the Project

1. Initialize the Project: Create a new Node.js project and install necessary dependencies.

   mkdir seerbit-multicurrency
   cd seerbit-multicurrency
   npm init -y
   npm install axios seerbit-nodejs node-schedule dotenv

2. Configure Environment Variables: Create a .env file to securely store your API keys.

   SEERBIT_PUBLIC_KEY=your_seerbit_public_key
   SEERBIT_SECRET_KEY=your_seerbit_secret_key
   SEERBIT_BEARER_TOKEN=your_seerbit_bearer_token
   EXCHANGE_RATE_API_KEY=your_exchange_rate_api_key

Ensure you replace placeholder text with your actual keys.

Step 2: Fetching Real-Time Exchange Rates

To display prices in various currencies, fetch the latest exchange rates.

1. Create a Module for Currency Conversion:

   // currencyConverter.js
   require('dotenv').config();
const axios = require('axios');

const apiKey = process.env.EXCHANGE_RATE_API_KEY;
const baseURL = 'https://api.currencyfreaks.com/v2.0/rates/latest';

async function convertCurrency(amount, fromCurrency, toCurrency){
    try{
        const response = await axios.get(baseURL, {
        params: {
            apikey: apiKey,
            symbols: toCurrency,
            base: fromCurrency
        }
        });
        const rate = response.data.rates[toCurrency];
        const convertedAmount = amount * rate;
        return convertedAmount.toFixed(2);
    }catch(error){
       console.error('Error fetching exchange rates:', error);
       throw new Error('Currency conversion failed');
    }
}

module.exports = convertCurrency;

This module fetches the exchange rate between specified currencies and calculates the converted amount.

2. Implement Regular Updates for Exchange Rates:

To keep exchange rates current, schedule regular updates.

   // exchangeRateUpdater.js
   const schedule = require('node-schedule');
const axios = require('axios');
require('dotenv').config();

const apiKey = process.env.EXCHANGE_RATE_API_KEY;
const baseUrl = 'https://api.currencyfreaks.com/v2.0/rates/latest';

async function updateExchangeRates(){
    try {
        const response = await axios.get(baseUrl, {
          params: {apikey: apiKey}
        });

        // Save response.data rates to your database or in-memory store
        console.log('Exchange rates updated:', response.data.rates);
    }catch(error){
    console.error('Error updating exchange rates:', error);
    }
}

// Schedule the job to run hourly
schedule.scheduleJob('0 * * * *', updateExchangeRates);

This script fetches and logs the latest exchange rates every hour.

Step 3: Generating the Bearer Token

To integrate SeerBit's payment services into your Node.js application, you'll need to generate a bearer token for API authentication. Here's how you can obtain this token and incorporate it into your existing code.

SeerBit requires an encrypted key, derived from your secret and public keys, to authenticate API requests. Follow these steps to generate the bearer token:

1. Prepare Your Keys:

Public Key: Obtain this from your SeerBit merchant dashboard.
Secret Key: Also available on your merchant dashboard.

2. Concatenate and Encrypt Keys:

Format: Combine your secret and public keys into a single string, separated by a period (.):

SECRET_KEY.PUBLIC_KEY

Encryption: Send this concatenated string to SeerBit's encryption endpoint to receive an encrypted key.

3. Request the Encrypted Key:

Endpoint: POST https://seerbitapi.com/api/v2/encrypt/keys
Headers: Set Content-Type to application/json.
Body: Include the concatenated key in the following JSON format:

{
  "key": "SECRET_KEY.PUBLIC_KEY"
}

Important Considerations:

Security: Handle your secret and public keys with care. Avoid exposing them in client-side code or public repositories.
Token Validity: The encryptedKey (bearer token) may have a validity period. Ensure you handle token expiration appropriately in your application.
Error Handling: Implement comprehensive error handling to manage potential issues during the token generation and payment initialization processes.

For detailed information, refer to SeerBit's official documentation on authentication and the Node.js SDK:

Authentication: https://apis.seerbit.com/authentication
Node.js SDK: https://github.com/seerbit/seerbit-nodejs

By following these steps, you can securely generate a bearer token and integrate SeerBit's payment services into your Node.js application.

Step 4: Processing Payments with SeerBit

Integrate SeerBit's payment gateway to handle transactions in the desired currency.

1. Initialize SeerBit's SDK:

   // seerbitPayment.js
   const {Client, Config, StandardCheckout} = require('seerbit-nodejs');
require('dotenv').config();

const config = new Config({
    publicKey: process.env.SEERBIT_PUBLIC_KEY,
    secretKey: process.env.SEERBIT_SECRET_KEY,
    bearerToken: process.env.SEERBIT_BEARER_TOKEN
});

const client = new Client(config);
const standardCheckout = new StandardCheckout(client);

async function initializePayment(amount, currency, email){
    const payload = {
        amount,
        callbackUrl: 'https://www.yourapp.com/callback',
        country: 'NG',
        currency,
        email,
        paymentReference: Date.now().toString()
    };

    try{
        const response = await standardCheckout.Initialize(payload);
        console.log('Payment initialized successfully:', response);
        return response;
    }catch(error){
        console.error('Error initializing payment:', error);
        throw error;
    }
}

module.exports = initializePayment;

This module sets up the SeerBit client and defines a function to initialize payments.

2. Integrate Conversion and Payment Initialization:

Combine currency conversion and payment initialization to handle multi-currency transactions.

   // app.js
   const convertCurrency = require('./currencyConverter');
   const initializePayment = require('./seerbitPayment');

   async function processPayment(amount, fromCurrency, toCurrency, email) {
       try {
           const convertedAmount = await convertCurrency(amount, fromCurrency, toCurrency);
            await initializePayment(convertedAmount, toCurrency, email);
       } catch (error) {
           console.error('Error processing payment:', error);
       }
   }

   // Example usage
   processPayment(100, 'USD', 'NGN', 'customer@example.com');

This script converts the amount from the source currency to the target currency and then initializes the payment with SeerBit.

Results

Checkout Payment Link Generated

Payment Form

Download the source code from github...

Conclusion

By following these steps, you can implement multi-currency support in your Node.js application using SeerBit. This integration ensures that customers can transact in their preferred currencies, enhancing user experience and expanding your market reach.

For more detailed information and advanced configurations, refer to the SeerBit API Documentation.

Thanks for reading...
Happy Coding!

Innovate with SeerBit

FOLASAYO SAMUEL OLAYEMI — Wed, 22 Jan 2025 10:13:03 +0000

In the rapidly evolving world of technology and digital finance, innovation is the driving force behind progress.
As businesses and developers seek efficient, secure and scalable payment solutions, SeerBit emerges as a trusted partner, empowering innovation at the intersection of fintech and creativity.
With a suite of developer-centric tools and APIs, SeerBit is reshaping the way payments are integrated, managed and optimized, fostering an ecosystem where innovation thrives.

Understanding SeerBit: A Catalyst for Change

SeerBit is more than a payment platform; it is a fintech enabler that bridges the gap between businesses and seamless financial transactions. Designed with the developer and end-user in mind, SeerBit’s ecosystem provides:

Comprehensive API Solutions: Developers can integrate SeerBit APIs into web and mobile applications, creating tailored payment solutions.
Security First: With PCI-DSS compliance and robust encryption protocols, SeerBit prioritizes the safety of every transaction.
Flexibility and Scalability: Whether for startups or established enterprises, SeerBit’s platform grows with your business, adapting to evolving needs.
By enabling developers to build innovative solutions, SeerBit catalyzes financial inclusion and technological advancement across industries.

Why Innovate with SeerBit?

Innovation is not just about creating new products; it’s about solving real-world problems in unique ways.
SeerBit equips businesses and developers with the tools they need to tackle challenges in the digital payment landscape.

Here’s why SeerBit is the ultimate choice for innovators:

Localized Solutions for Global Problems
Africa, with its growing digital economy, faces unique challenges—from underbanked populations to infrastructure gaps.
SeerBit’s localized approach ensures that its solutions are designed to meet regional needs while maintaining global standards.
Developers and businesses can leverage this local expertise to create impactful solutions.
Developer-Centric Tools
SeerBit’s platform offers comprehensive developer documentation, SDKs, and sandbox environments that simplify integration and testing. This reduces the time-to-market for new products, allowing developers to focus on creating value rather than navigating technical hurdles.
Empowering Small and Medium Enterprises (SMEs)
SMEs often struggle with access to reliable and affordable payment solutions.

SeerBit’s flexible pricing and scalable features make it an ideal choice for small businesses aiming to compete on a larger scale.
By integrating SeerBit, SMEs can offer their customers a seamless and secure payment experience, fostering growth and customer loyalty.

Fostering Innovation through Collaboration SeerBit actively collaborates with developers, entrepreneurs and businesses through hackathons, workshops and community programs. These initiatives provide opportunities to explore new ideas, test prototypes, and receive feedback, creating an environment where innovation flourishes.

SeerBit’s Key Features for Innovators

To empower developers and businesses, SeerBit offers a range of features designed to streamline payment processes and drive innovation:

Seamless Integration: With ready-to-use SDKs for popular programming languages and frameworks (e.g., Python, Node.js, Flutter), SeerBit simplifies the integration process.
Comprehensive Payment Options: From mobile money and card payments to bank transfers, SeerBit supports diverse payment methods, enabling businesses to cater to a wider audience.
Real-Time Analytics: Gain actionable insights into transaction data with SeerBit’s analytics dashboard, helping businesses make informed decisions.
Recurring Payments: Automate billing cycles with SeerBit’s subscription and recurring payment features, ideal for businesses with subscription-based models.
Global Reach with Local Expertise: While offering a global payment network, SeerBit’s localized understanding ensures that businesses can tap into the specific needs of African markets.

Success Stories: Innovating with SeerBit

Startups: A tech startup focused on providing subscription-based educational content leveraged SeerBit’s recurring payment feature to automate billing, reducing manual errors and improving cash flow management.
Fintech Developers: Developers building fintech apps have used SeerBit’s sandbox environment to prototype and test their solutions, shortening development cycles and ensuring robust performance at launch.

How to Get Started with SeerBit

Ready to innovate with SeerBit? Here’s how to begin:

Sign Up: Create an account on the SeerBit platform to access the dashboard and developer tools.
Explore Documentation: Dive into SeerBit’s extensive documentation to understand how the APIs work and explore use cases.
Build and Test: Use the sandbox environment to build and test your integration.
Launch Your Solution: Once ready, deploy your solution and start accepting payments seamlessly.
Join the Community: Participate in SeerBit’s developer forums, events, and ambassador programs to connect with other innovators and stay updated on the latest features.

The Future of Innovation with SeerBit

As the digital payment landscape continues to evolve, SeerBit remains committed to empowering businesses and developers with cutting-edge solutions.
By fostering a culture of innovation and collaboration, SeerBit is not only shaping the future of payments, but also driving economic growth and financial inclusion across Africa and beyond.
So, whether you’re an entrepreneur looking to streamline your payment processes, a developer building the next big fintech app, or a business aiming to scale globally, SeerBit is your partner in innovation.

Together, let’s transform challenges into opportunities and redefine the possibilities of digital finance.

Thanks for reading...
Happy Coding!

DEV Community: SeerBit Developers

Integrating SeerBit Payments in Angular

Prerequisites

Step 1: Install the Library

Step 2: Import the Module

Quick Tip: Need app.module.ts? Create a Module-Based Project

Step 3: Set Up Your Component Logic

Step 4: Add the UI

As a Component

As a Directive

Step 5: Add Some Basic CSS

Step 6: Run & Test

Bonus: Shopping Cart Demo

Summary

Implementing SeerBit Payment Solution in a Full-Stack Application Using ReactJS and NodeJS

Prerequisites

Project Setup

1. Initialize the Backend (NodeJS)

2. Create the Frontend (ReactJS)

Step 1: Get Your SeerBit API Keys

Request the Encrypted Key:

Step 2: Create Payment Route in NodeJS

Step 3: Create the Payment Interface in ReactJS

Step 4: Test the Integration

Best Practices for Production

Conclusion

Resources

How to Easily Integrate the SeerBit Payment Solution with React.js

Introduction

Prerequisites

Step 1: Obtain Your Public Key

Step 2: Install the SDK

Step 3: Configure Environment Variables

Step 4: Using the SDK as a React Hook

Step 5: Using the Prebuilt Button Component

Step 6: Testing Your Integration

Error Handling & Logging

Best Practices

Conclusion

References

INTEGRATING SEERBIT NODE.JS SDK IN YOUR APPLICATION

Introduction

Prerequisites

Installation

Generating the Bearer Token

Configuration

Basic Usage Examples

Advanced Features

Error Handling and Logging

Best Practices

Conclusion

Earn with Ease: Introducing the SeerBit Partner Dashboard

What is the SeerBit Partner Dashboard?

How Does It Work?

Conclusion

SeerBit Enhanced Merchant Services

OVERVIEW OF SEERBIT MERCHANT DASHBOARD AND INFRASTRUCTURE ENHANCEMENTS FOR MERCHANTS

Strategic Collaborations Amplifying Merchant Services

Merchant Success Stories

Benefits of SeerBit's Initiatives for Merchants and Developers

For Merchants:

For Developers:

Future Outlook

Conclusion

Accepting Multiple Currencies with SeerBit: A Developer's Guide

SeerBit's Multi-Currency Capabilities

Supported Currencies and Regions

Automatic Currency Conversion Features

Prerequisites

Step 1: Setting Up the Project

Step 2: Fetching Real-Time Exchange Rates

Step 3: Generating the Bearer Token

Step 4: Processing Payments with SeerBit

Results

Conclusion

Innovate with SeerBit

Understanding SeerBit: A Catalyst for Change

Why Innovate with SeerBit?

SeerBit’s Key Features for Innovators

Success Stories: Innovating with SeerBit

Quick Tip: Need `app.module.ts`? Create a Module-Based Project