DEV Community: Akinshola Samuel AKINDE

Bridging Fintech and Agentic AI: Building a Paystack MCP Server in Python

Akinshola Samuel AKINDE — Wed, 25 Mar 2026 05:09:06 +0000

If you’ve been following the AI space lately, you’ve probably heard of the Model Context Protocol (MCP). It is rapidly becoming the gold standard for connecting Large Language Models (LLMs) to external tools and databases.

We are seeing a massive surge in MCP servers for developer tools like GitHub, Postgres, and SQLite. But what about the Fintech space? It has remained largely untapped—until now.

I’m excited to share a project I had published over 6months ago on GitHub: the Paystack MCP Server. It’s a Python-based server that bridges the gap between Paystack (Africa’s premier payment gateway) and agentic AI interfaces like Claude Desktop.

Instead of writing manual cURL requests or digging through your Paystack dashboard, you can now just ask your AI agent to verify transactions, fetch customer details, or process refunds. Let's dive into how it works and how you can run it locally!

Core Capabilities

The Paystack MCP Server wraps the Paystack API into "Tools" that LLMs can naturally understand and execute. Currently, the server exposes the following critical endpoints:

verify_transaction: Confirms the status of a payment using a reference code.
fetch_transaction: Retrieves detailed metadata about a specific transaction ID.
create_customer: Registers a new customer on your Paystack integration.
fetch_customer: Retrieves customer details via email or ID.
list_transactions: Fetches a history of recent transactions (with pagination support).
initiate_refund: Processes refunds for disputes or errors.

Technical Deep Dive: How the Logic Works

I built this project using Python and the official mcp SDK. Right now, it leverages a synchronous architecture (using the good old requests library) for solid reliability.

At its core, the server uses the FastMCP pattern to strip away unnecessary boilerplate. Here is how the flow works when you prompt your AI:

You ask: "Check if transaction T12345 was successful."
Claude (MCP Client): Sees that the verify_transaction tool perfectly matches your intent.
MCP Server: Receives the tool call and routes it directly to our Python function.
Paystack API: The function fires a GET request to https://api.paystack.co/transaction/verify/T12345.
Response: The JSON data is cleaned up, formatted, and sent back to the LLM so it can reply to you in natural language.

Code Sample: Transaction Verification

Here is a quick look under the hood at how the verification logic is implemented (simplified for readability):

from mcp.server.fastmcp import FastMCP
import requests
import os

# Initialize the MCP Server
mcp = FastMCP("paystack")

BASE_URL = "https://api.paystack.co"
HEADERS = {
    "Authorization": f"Bearer {os.getenv('PAYSTACK_SECRET_KEY')}",
    "Content-Type": "application/json"
}

@mcp.tool()
def verify_transaction(reference: str) -> str:
    """
    Verifies the status of a transaction using its reference.

    Args:
        reference: The unique transaction reference code.
    """
    url = f"{BASE_URL}/transaction/verify/{reference}"
    response = requests.get(url, headers=HEADERS)

    if response.status_code == 200:
        data = response.json().get('data', {})
        status = data.get('status')
        amount = data.get('amount') / 100  # Convert kobo to major unit
        return f"Transaction {reference} is {status}. Amount: {amount}."
    else:
        return f"Error verifying transaction: {response.text}"

Installation & Setup

Ready to try it out? You can run this server locally or spin it up via Docker.

Prerequisites:

Python 3.10+
A Paystack Account (and your Secret Key)
uv (highly recommended) or pip

Option 1: Local Development (via UV)

Clone the repo:

   git clone https://github.com/thisishaykins/paystack-python-mcp
   cd paystack-python-mcp

Set up your environment variables: Create a .env file or export your key directly in the terminal:

   export PAYSTACK_SECRET_KEY="sk_test_..."

Run the Server:

   uv run paystack_mcp.py

Option 2: Docker Deployment

If you prefer isolated environments, Docker is the way to go.

Dockerfile Example:

FROM python:3.10-slim

WORKDIR /app

# Install dependencies
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copy source code
COPY . .

# Set entrypoint
ENTRYPOINT ["python", "paystack_mcp.py"]

Run it:

docker build -t paystack-mcp .
docker run -e PAYSTACK_SECRET_KEY="sk_test_..." -i paystack-mcp

(Note: That -i flag is super important because MCP communicates over Stdio!)

Integrating with Claude Desktop

To get this working inside your Claude Desktop app, you just need to update your claude_desktop_config.json file.

Where to find it:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json

Add this configuration:

{
  "mcpServers": {
    "paystack": {
      "command": "uv",
      "args": [
        "run",
        "--with",
        "requests",
        "/absolute/path/to/paystack-python-mcp/paystack_mcp.py"
      ],
      "env": {
        "PAYSTACK_SECRET_KEY": "sk_test_YOUR_KEY_HERE"
      }
    }
  }
}

Real-World Scenarios in Action

Once you are hooked up, it feels like magic. Here is what you can do:

Scenario 1: Quick Support Investigation

You: "I have a customer, john@example.com, claiming he paid for the Premium Plan but it's not showing. Can you check his last 3 transactions?"

Claude's Actions:

Triggers fetch_customer(email="john@example.com") to grab the Customer ID.
Triggers list_transactions(customer_id=123, per_page=3).
Response: "I found John. His last 3 transactions were all 'Failed'. He attempted to pay 5000 NGN but the bank declined."

Scenario 2: Processing Instant Refunds

You: "Transaction REF-998877 was a duplicate charge. Please refund it immediately."

Claude's Actions:

Triggers verify_transaction(reference="REF-998877") to check the status.
Triggers initiate_refund(transaction="REF-998877").
Response: "Refund initiated successfully for transaction REF-998877."

🔮 What's Next? Going Async

This current version is robust, but I'm already working on a v2 release to handle high-throughput workflows (imagine asking Claude to audit 50 transactions at once). Here's a tested branch: https://github.com/thisishaykins/paystack-python-mcp/tree/feature/v2-async-refactor

Here is what is on the immediate roadmap:

Async/Await: Swapping requests for httpx and asyncio for non-blocking API calls.
Webhooks: Allowing Paystack to push live updates back to the MCP server.
Bulk Operations: Dedicated tools for managing bulk transfers.

I’d love for you to try it out, break it, and contribute!

Check out the repo here: github.com/thisishaykins/paystack-python-mcp

Please drop a star ⭐ if you find it useful, and let me know in the comments what Fintech tools you'd like to see integrated next!

Shipping Desktop Apps with PHP? Let’s Talk NativePHP for Startups

Akinshola Samuel AKINDE — Tue, 17 Mar 2026 04:17:25 +0000

Hey Guys... Haykins here 😊. Are you a PHP lover tired of being told you can't build "real" desktop apps? Scratch that. Let’s talk about taking your Laravel skills and wrapping them into a powerful desktop experience without touching a line of Swift or C#.

If you’re an early-stage startup founder or a solo-dev trying to ship fast, NativePHP might just be the "ginger" your product needs. But is it ready for the big leagues? Let’s dive into the pros, the cons, and the real impact on your throughput.

Quick Gist of NativePHP

NativePHP isn’t a new language; it’s a framework that lets you use the PHP tools you already love (like Laravel) to build native-like desktop applications. It uses Electron or Tauri under the hood to bridge the gap between your web code and the user's OS.

#1 The Pros: Why Your Startup Might Need This

Developer Velocity (The Hustle): You don't need to hire a separate macOS and Windows team. If you know PHP, you’re already a desktop developer.
Unified Codebase: Share your logic, validation, and even your CSS between your web app and your desktop app.
Low Barrier to Entry: No need to learn complex memory management or UI kits like Cocoa. It’s just PHP and HTML/JS.

#2 The Cons: The "Hold On A Minute" Section

Binary Size: Because it bundles a whole PHP runtime and Electron, your "Hello World" app might be a bit chunky (100MB+).
Alpha/Beta Status: NativePHP is still fresh. You might hit some bugs that don't have a StackOverflow answer yet.
Performance Overhead: For high-intensity data processing, a native C++ or Rust app will always win.

#3 Impact and Rate of Throughput

In a startup, throughput = features shipped.

Impact: You can turn a web-based SaaS into a desktop tool (with system tray icons and global shortcuts) in a weekend.
Throughput: Your "Time to Market" (TTM) drops significantly. Instead of 3 months for a cross-platform build, you're looking at maybe 2 weeks of tweaking.

Final 2kobo (thoughts 😊)

NativePHP is a game-changer for the "ship-it" culture. It allows you to leverage your existing PHP expertise to enter new markets (desktop users) with minimal overhead. While it's still growing, the potential for rapid prototyping is insane.

How to configure multiple databases on individual domain names using a single Odoo instance? [A Multi-Tenant Odoo App]

Akinshola Samuel AKINDE — Thu, 29 May 2025 15:25:31 +0000

Hey Guys... Haykins here 😊. Are you tired of managing multiple Odoo servers for different clients? scratch that. Let’s dockerize your hustle, make it scalable, and give each client their own domain — all on one Odoo engine. this also works out for B2B Startup adopting Odoo for their customers operational activities.

Quick Gist of what we are doing

We will be developing an Odoo setup where:

And Odoo instance that serves multiple clients
Each client has their own database
Each database is accessible via a custom domain or subdomain like:
- client-1.haykinsodoo.docker
- client-2.haykinsodoo.docker
- client-3.haykinsodoo.docker
Lastly, using Docker, PostgreSQL, Traefik for SSL & routing, sprinkles of Naija developer ginger 😎, and my PC with internet. NEPA or not 😅.

Now, let's get into it...

#1 Project Structure

let's get the project structure setup in this format:

├── docker-compose.yml
├── .env
├── odoo.conf
└── traefik/
    ├── traefik.yml
    └── acme.json

#2 Setting up Environment Variables

we will be creating an .env file on the root folder.

ODOO_VERSION=18.0
ODOO_DB_USER=odoo
ODOO_DB_PASSWORD=password
POSTGRES_PASSWORD=password
DOMAINS=client-1.haykinsodoo.docker,client-2.haykinsodoo.docker,client-3.haykinsodoo.docker

#3 Setting up Docker Compose YAML

Next, we will be setting up the docker-compose.yml file

# version: "3.9"
# Odoo with Traefik and PostgreSQL
# This docker-compose file sets up Odoo with Traefik as a reverse proxy and PostgreSQL as the database.

services:
  db:
    image: postgres:15
    environment:
      - POSTGRES_USER=${ODOO_DB_USER}
      - POSTGRES_PASSWORD=${POSTGRES_PASSWORD}
      - PGDATA=/var/lib/postgresql/data/pgdata
    ports:
      - 8432:5432
    volumes:
      - db-data:/var/lib/postgresql/data
    secrets:
      - postgresql_password

  odoo:
    image: odoo:${ODOO_VERSION}
    depends_on:
      - db
    environment:
      - HOST=db
      - USER=${ODOO_DB_USER}
      - PASSWORD=${ODOO_DB_PASSWORD}
    secrets:
      - postgresql_password
    ports:
      - "8069:8069"
      - "8072:8072"
    volumes:
      - odoo-data:/var/lib/odoo
      - ./odoo.conf:/etc/odoo/odoo.conf
      - ./addons:/mnt/extra-addons
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.odoo.rule=HostRegexp(`{subdomain:.+}.haykinsodoo.docker`)"
      - "traefik.http.routers.odoo.entrypoints=web"
      # - "traefik.http.routers.odoo.entrypoints=websecure"
      # - "traefik.http.routers.odoo.tls=true"
      # - "traefik.http.routers.odoo.tls.certresolver=letsencrypt"
      - "traefik.http.services.odoo.loadbalancer.server.port=8069"

  traefik:
    image: traefik:v2.10
    command:
      - --api.insecure=true
      - --providers.docker=true
      # - --entrypoints.websecure.address=:443
      - --entrypoints.web.address=:80
      - --certificatesresolvers.letsencrypt.acme.httpchallenge=true
      - --certificatesresolvers.letsencrypt.acme.httpchallenge.entrypoint=web
      - --certificatesresolvers.letsencrypt.acme.email=admin@haykinsodoo.docker
      - --certificatesresolvers.letsencrypt.acme.storage=/letsencrypt/acme.json
    ports:
      - "80:80"
      - "443:443"
      - "8080:8080"  # Traefik dashboard port
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - ./traefik/traefik.yml:/traefik.yml
      - ./traefik/acme.json:/letsencrypt/acme.json

volumes:
  db-data:
  odoo-data:

secrets:
  postgresql_password:
    file: odoo_pg_pass

#4 Setting up the Odoo Configuration

We continue with creatinf an odoo.conf file and adding our configurations

[options]
addons_path = /mnt/extra-addons
admin_passwd = admin
db_host = db
db_port = 5432
db_user = odoo
db_password = password
dbfilter = ^%d$
xmlrpc_interface = 0.0.0.0
log_level = info

This dbfilter = ^%d$ simply means when the site: client-1.haykinsodoo.docker is visited, Odoo will open client_1 as the database.

#5 Setting and Configuring Traefik

Let's create a traefik/traefik.yml

entryPoints:
  web:
    address: ":80"
  websecure:
    address: ":443"
  traefik:
    address: ":8080"

api:
  dashboard: true
  insecure: true

providers:
  docker:
    exposedByDefault: false

Also, create acme.json and set file permissions (access rights) to 600, so that only the file owner has read and write access, while no one else, including the group and others, has any access.

$ touch traefik/acme.json # create the file

$ chmod 600 traefik/acme.json # change file permission

#5 Let's get everything up and running

docker-compose up -d

Oshee! Our Odoo live... For us to access the different instances

client-1.haykinsodoo.docker will serve the client-1 database. (note: ensure to copy the master password which will be re-used for all other clients installations)
client-2.haykinsodoo.docker will serve the client-2 database.
client-3.haykinsodoo.docker will serve the client-3 database.

Note In Prod: Make sure those subdomains point to your VPS/public IP address (you can use your domain provider’s DNS settings to handle this).

Bonus Bonus Bonus: Create a DB Manually (Optional)

$ docker exec -it <odoo_container_id> /bin/bash

# run the below code inside container
$ odoo -d client-1 --init=base --stop-after-init

Final 2kobo (thoughts 😊)

This entire process and setup gives you the power to serve, scale, and secure multiple Odoo clients like a true Odoo Developer and/or DevOps engineer. It’s modular, clean, and cheap to maintain.

So whether you’re a developer, startup founder, or building the next ERP-as-a-Service, this is your kick-off point. With this setup, you're running your own multi-tenant Odoo app.

visit my GitHub for the full code setup: https://github.com/thisishaykins/multi-tenant-odoo-app

🙌 Shoutout

Written by a Dev for Devs, proudly from the land of jollof, generators, and pure tech vibes. 🇳🇬
Built this with:

My PC
VS Code
Docker
Odoo
Postgres
Traefik
Naija jollof rice 🌶️

Drop your questions below or tag me on Twitter/X: @thisishaykins