Hey there! Welcome to this fun and practical workshop on using the NabooPay Python SDK. Whether you're syncing up synchronously or diving into async adventures, this guide has got you covered. We'll walk through installing the SDK, setting up clients, and performing some cool operations like retrieving account details, managing transactions, and handling cashouts. I’ve added a sprinkle of humor to keep things light because who said coding can’t be fun, right? Let’s dive in!
- Installation
- Client Initialization
- 2.1 Token Loading
- 2.2 Synchronous Client
- 2.3 Asynchronous Client
- Operations
- 3.1 Retrieve Account Details
- 3.1.1 Synchronous
- 3.1.2 Asynchronous
- 3.2 Transactions
- 3.2.1 Create Transaction
- 3.2.1.1 Synchronous
- 3.2.1.2 Asynchronous
- 3.2.2 Delete Transaction
- 3.2.2.1 Synchronous
- 3.2.2.2 Asynchronous
- 3.2.3 Get Transactions
- 3.2.3.1 Synchronous
- 3.2.3.2 Asynchronous
- 3.2.1 Create Transaction
- 3.3 Cashout
- 3.3.1 Cashout with Wave
- 3.3.1.1 Synchronous
- 3.3.1.2 Asynchronous
- 3.3.2 Cashout with Orange Money
- 3.3.2.1 Synchronous
- 3.3.2.2 Asynchronous
- 3.3.1 Cashout with Wave
- 3.1 Retrieve Account Details
Let’s kick things off by installing the NabooPay Python SDK with this magical command. Run it in your terminal, and you’re good to go! with pip
pip install naboopay
for development :
pip install git+https://github.com/naboopay/naboopay-python-sdk.gitwith uv (faster)
uv pip install git+https://github.com/naboopay/naboopay-python-sdk.gitBefore we can do anything fancy, we need to set up our clients. This involves loading our API token and initializing both synchronous and asynchronous clients. Here’s how:
First, grab your API token from a .env file—it’s the safest way to keep your secrets, well, secret! If you don’t have one yet, head to the NabooPay dashboard and conjure one up.
from dotenv import load_dotenv
import os
load_dotenv()
token = os.environ.get("NABOO_API_KEY")
# Alternatively: token = "your_token_here" (but shh, that’s not safe!)
# You wanna know my phone number 😂, no bro you can't 🙃 let's load them as env var
phone_number_1 = os.environ.get("TEST_NUMBER_1")
phone_number_2 = os.environ.get("TEST_NUMBER_2")For those who like to take things one step at a time, here’s how to set up the synchronous client:
from naboopay import NabooPay
naboopay_client = NabooPay(token=token)If you’re ready to live on the async edge, initialize the asynchronous client like this:
from naboopay import NabooPayAsync
naboopay_async_client = NabooPayAsync(token=token)Now for the fun part let’s do stuff with the NabooPay API! We’ll cover retrieving account details, managing transactions, and cashing out, with examples for both synchronous and asynchronous approaches.
Let’s peek at your account info.
Simple and straightforward get your account details and print them:
account_info_sync = naboopay_client.account.get_info()
print(account_info_sync)For the async fans, here’s how to fetch account details. Don’t forget to run it with asyncio:
import asyncio
async def account_test():
account_info_async = await naboopay_async_client.account.get_info()
print(account_info_async)
asyncio.run(account_test())Time to play with transactions, create them, delete them, and fetch them!
Let’s whip up a transaction with some payment methods and a snazzy T-shirt product. Feel free to add more items (maybe a “Unicorn Horn”?) as long as it’s legal!
from naboopay.models import TransactionRequest, ProductModel, Wallet
request = TransactionRequest(
method_of_payment=[Wallet.WAVE, Wallet.ORANGE_MONEY, Wallet.FREE_MONEY],
products=[
ProductModel(
name="T-shirt",
category="clothing",
amount=10000,
quantity=1,
description="test description",
),
# Add more products here if you’re feeling fancy!
],
)Create that transaction and see what you get:
from naboopay.models import TransactionResponse
response_sync: TransactionResponse = naboopay_client.transaction.create(request=request)
print(response_sync)Async creation because why wait around?
async def create_transaction_async():
response_async: TransactionResponse = await naboopay_async_client.transaction.create(request=request)
print(response_async)
return response_async
response_async = asyncio.run(create_transaction_async())Got a transaction you don’t like? Let’s delete it using the order_id from the creation step.
Using the response_sync from above:
from naboopay.models import DeleteTransactionRequest
request_sync_delete = DeleteTransactionRequest(order_id=response_sync.order_id)
response_sync_delete = naboopay_client.transaction.delete(request=request_sync_delete)
print(response_sync_delete)Using the response_async from the async creation:
request_async_delete = DeleteTransactionRequest(order_id=response_async.order_id)
async def delete_transaction_async():
response_async_delete = await naboopay_async_client.transaction.delete(request=request_async_delete)
print(response_async_delete)
asyncio.run(delete_transaction_async())Want to see all your transactions or just one? Here’s how:
Fetch all transactions:
all_transactions_sync = naboopay_client.transaction.get_all()
print(all_transactions_sync)Grab a single transaction using an order_id (we’ll use the first one from the list):
transaction_id = all_transactions_sync.transactions[0].order_id
one_transaction_sync = naboopay_client.transaction.get_one(order_id=transaction_id)
print(one_transaction_sync)All transactions, async style:
async def get_all_transactions_async():
all_transactions_async = await naboopay_async_client.transaction.get_all()
print(all_transactions_async)
asyncio.run(get_all_transactions_async())One transaction, async style:
async def get_one_transaction_async():
one_transaction_async = await naboopay_async_client.transaction.get_one(order_id=transaction_id)
print(one_transaction_async)
asyncio.run(get_one_transaction_async())Let’s move some money with Wave and Orange Money. Pro tip: use your own phone number for testing unless you want to surprise sudoping01!
Set up your cashout request:
from naboopay.models import CashOutRequest
request_wave: CashOutRequest = CashOutRequest(
full_name="sudoping01",
amount=10000,
phone_number=phone_number_1, # Don’t change this unless you’re testing sudoping01 likes it this way! 😂
)Cash out and handle any hiccups:
try:
response_wave_sync = naboopay_client.cashout.wave(request=request_wave)
print(response_wave_sync)
except Exception as e:
print(f"Exception: {e}")Async cashout with error handling:
async def cashout_wave_async():
try:
response_wave_async = await naboopay_async_client.cashout.wave(request=request_wave)
print(response_wave_async)
except Exception as e:
print(f"Exception: {e}")
asyncio.run(cashout_wave_async())Another cashout, this time with Orange Money:
request_orange: CashOutRequest = CashOutRequest(
full_name="Djim Patrick Lo", # Hi Patrick! 😂
amount=100,
phone_number=phone_number_2, # Swap this out for testing, or Patrick might cash in!
)try:
response_orange_sync = naboopay_client.cashout.orange_money(request=request_orange)
print(response_orange_sync)
except Exception as e:
print(f"Exception: {e}")async def cashout_orange_async():
try:
response_orange_async = await naboopay_async_client.cashout.orange_money(request=request_orange)
print(response_orange_async)
except Exception as e:
print(f"Exception: {e}")
asyncio.run(cashout_orange_async())And there you have it a full workshop on using the NabooPay Python SDK! You’ve installed it, set up clients, and mastered account details, transactions, and cashouts both synchronously and asynchronously. Pretty cool, right? Feel free to tweak the code, explore more features, and keep the good vibes going. Good Integration 🫂!